--- /dev/null
--- /dev/null
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/deps/try_signal/.travis.yml
++@@ -0,0 +1,44 @@
+++language: cpp
+++matrix:
+++ include:
+++ - env: toolset=gcc
+++ - os: osx
+++ osx_image: xcode11.2
+++ env: toolset=darwin
+++
+++branches:
+++ only:
+++ - master
+++
+++git:
+++ submodules: false
+++ depth: 1
+++
+++addons:
+++ apt:
+++ sources:
+++ - ubuntu-toolchain-r-test
+++ packages:
+++ - libboost-tools-dev
+++ - g++-9
+++
+++install:
+++
+++ - 'if [[ $TRAVIS_OS_NAME == "osx" ]]; then brew update > /dev/null && brew install boost-build; fi'
+++ - 'if [[ $TRAVIS_OS_NAME != "osx" ]]; then
+++ export B2=bjam;
+++ else
+++ export B2=b2;
+++ fi'
+++ - touch ~/user-config.jam
+++ - 'if [[ $toolset == "gcc" ]]; then
+++ g++-5 --version;
+++ echo "using gcc : : g++-5 : <cxxflags>-std=c++11 ;" >> ~/user-config.jam;
+++ fi'
+++ - 'echo "using darwin : : clang++ : <cxxflags>-std=c++11 ;" >> ~/user-config.jam'
+++
+++script:
+++
+++ - ${B2} link=static stage_test
+++ - ./test
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/deps/try_signal/CMakeLists.txt
++@@ -0,0 +1,6 @@
+++cmake_minimum_required(VERSION 2.8.12)
+++project(try_signal)
+++
+++add_library(try_signal signal_error_code try_signal)
+++target_include_directories(try_signal PUBLIC .)
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/deps/try_signal/Jamfile
++@@ -0,0 +1,18 @@
+++lib try_signal
+++ : # sources
+++ signal_error_code.cpp try_signal.cpp
+++ : # requirements
+++ : # default build
+++ <link>static
+++ : # usage requirements
+++ <include>.
+++ ;
+++
+++exe test : test.cpp : <library>try_signal <link>static ;
+++explicit test ;
+++
+++exe example : example.cpp : <library>try_signal <link>static ;
+++explicit example ;
+++
+++install stage_test : test : <location>. ;
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/deps/try_signal/LICENSE
++@@ -0,0 +1,29 @@
+++BSD 3-Clause License
+++
+++Copyright (c) 2016, Arvid Norberg
+++All rights reserved.
+++
+++Redistribution and use in source and binary forms, with or without
+++modification, are permitted provided that the following conditions are met:
+++
+++* Redistributions of source code must retain the above copyright notice, this
+++ list of conditions and the following disclaimer.
+++
+++* Redistributions in binary form must reproduce the above copyright notice,
+++ this list of conditions and the following disclaimer in the documentation
+++ and/or other materials provided with the distribution.
+++
+++* Neither the name of the copyright holder nor the names of its
+++ contributors may be used to endorse or promote products derived from
+++ this software without specific prior written permission.
+++
+++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+++DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+++FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+++DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+++SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+++CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+++OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+++OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/deps/try_signal/README.rst
++@@ -0,0 +1,53 @@
+++try_signal
+++==========
+++
+++.. image:: https://travis-ci.org/arvidn/try_signal.svg?branch=master
+++ :target: https://travis-ci.org/arvidn/try_signal
+++
+++.. image:: https://ci.appveyor.com/api/projects/status/le8jjroaai8081f1?svg=true
+++ :target: https://ci.appveyor.com/project/arvidn/try-signal/branch/master
+++
+++The ``try_signal`` library provide a way to turn signals into C++ exceptions.
+++This is especially useful when performing disk I/O via memory mapped files,
+++where I/O errors are reported as ``SIGBUS`` and ``SIGSEGV`` or as structured
+++exceptions on windows.
+++
+++The function ``try_signal`` takes a function object that will be executed once.
+++If the function causes a signal (or structured exception) to be raised, it will
+++throw a C++ exception. Note that RAII may not be relied upon within this function.
+++It may not rely on destructors being called. Stick to simple operations like
+++memcopy.
+++
+++Example::
+++
+++ #include <stdexcept>
+++ #include <vector>
+++ #include <numeric>
+++ #include "try_signal.hpp"
+++ #include <fcntl.h>
+++ #include <unistd.h>
+++ #include <sys/mman.h>
+++
+++ int main() try
+++ {
+++ int fd = open("test_file", O_RDWR);
+++ void* map = mmap(nullptr, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+++
+++ std::vector<char> buf(1024);
+++ std::iota(buf.begin(), buf.end(), 0);
+++
+++ // disk full or access after EOF are reported as exceptions
+++ sig::try_signal([&]{
+++ std::memcpy(map, buf.data(), buf.size());
+++ });
+++
+++ munmap(map, 1024);
+++ close(fd);
+++ return 0;
+++ }
+++ catch (std::exception const& e)
+++ {
+++ fprintf(stderr, "exited with exception: %s\n", e.what());
+++ return 1;
+++ }
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/deps/try_signal/appveyor.yml
++@@ -0,0 +1,50 @@
+++version: "{build}"
+++branches:
+++ only:
+++ - master
+++os: Visual Studio 2015
+++clone_depth: 1
+++environment:
+++ matrix:
+++ - variant: debug
+++ compiler: msvc-14.0
+++ model: 64
+++ - variant: debug
+++ compiler: msvc-14.0
+++ model: 32
+++ - variant: release
+++ compiler: msvc-14.0
+++ model: 64
+++ - variant: debug
+++ compiler: gcc
+++ model: 32
+++ - variant: debug
+++ compiler: gcc
+++ model: 64
+++ - variant: release
+++ compiler: gcc
+++ model: 32
+++
+++install:
+++- set ROOT_DIRECTORY=%CD%
+++- set BOOST_ROOT=c:\Libraries\boost_1_67_0
+++- set BOOST_BUILD_PATH=%BOOST_ROOT%\tools\build
+++- echo %BOOST_ROOT%
+++- echo %BOOST_BUILD_PATH%
+++- set PATH=%PATH%;%BOOST_BUILD_PATH%\src\engine\bin.ntx86
+++- ps: '"using msvc : 14.0 ;`nusing gcc : : : <cxxflags>-std=c++11 ;" | Set-Content $env:HOMEDRIVE\$env:HOMEPATH\user-config.jam'
+++- type %HOMEDRIVE%%HOMEPATH%\user-config.jam
+++- set PATH=c:\msys64\mingw32\bin;%PATH%
+++- g++ --version
+++- python --version
+++- echo %ROOT_DIRECTORY%
+++- cd %BOOST_BUILD_PATH%\src\engine
+++- build.bat >nul
+++- cd %ROOT_DIRECTORY%
+++
+++build_script:
+++# examples
+++- b2.exe warnings=all warnings-as-errors=on -j2 %compiler% address-model=%model% variant=%variant% stage_test
+++
+++test_script:
+++- test
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/deps/try_signal/example.cpp
++@@ -0,0 +1,31 @@
+++#include <stdexcept>
+++#include <vector>
+++#include <numeric>
+++#include "try_signal.hpp"
+++#include <fcntl.h>
+++#include <unistd.h>
+++#include <sys/mman.h>
+++
+++int main() try
+++{
+++ int fd = open("test_file", O_RDWR);
+++ void* map = mmap(nullptr, 1024, PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0);
+++
+++ std::vector<char> buf(1024);
+++ std::iota(buf.begin(), buf.end(), 0);
+++
+++ // disk full or access after EOF are reported as exceptions
+++ sig::try_signal([&]{
+++ std::memcpy(map, buf.data(), buf.size());
+++ });
+++
+++ munmap(map, 1024);
+++ close(fd);
+++ return 0;
+++}
+++catch (std::exception const& e)
+++{
+++ fprintf(stderr, "exited with exception: %s\n", e.what());
+++ return 1;
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/deps/try_signal/signal_error_code.cpp
++@@ -0,0 +1,209 @@
+++/*
+++
+++Copyright (c) 2016, Arvid Norberg
+++All rights reserved.
+++
+++Redistribution and use in source and binary forms, with or without
+++modification, are permitted provided that the following conditions
+++are met:
+++
+++ * Redistributions of source code must retain the above copyright
+++ notice, this list of conditions and the following disclaimer.
+++ * Redistributions in binary form must reproduce the above copyright
+++ notice, this list of conditions and the following disclaimer in
+++ the documentation and/or other materials provided with the distribution.
+++ * Neither the name of the author nor the names of its
+++ contributors may be used to endorse or promote products derived
+++ from this software without specific prior written permission.
+++
+++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+++POSSIBILITY OF SUCH DAMAGE.
+++
+++*/
+++
+++#include <system_error>
+++#include <string>
+++
+++#include "signal_error_code.hpp"
+++
+++namespace {
+++
+++ struct signal_error_category : std::error_category
+++ {
+++ const char* name() const noexcept override
+++ { return "signal"; }
+++ std::string message(int ev) const noexcept override
+++ {
+++#define SIGNAL_CASE(x) case sig::errors::error_code_enum:: x: return #x;
+++ switch (ev)
+++ {
+++ SIGNAL_CASE(abort)
+++ SIGNAL_CASE(alarm)
+++ SIGNAL_CASE(arithmetic_exception)
+++ SIGNAL_CASE(hangup)
+++ SIGNAL_CASE(illegal)
+++ SIGNAL_CASE(interrupt)
+++ SIGNAL_CASE(kill)
+++ SIGNAL_CASE(pipe)
+++ SIGNAL_CASE(quit)
+++ case sig::errors::error_code_enum::segmentation: return "segmentation fault";
+++ SIGNAL_CASE(terminate)
+++ SIGNAL_CASE(user1)
+++ SIGNAL_CASE(user2)
+++ SIGNAL_CASE(child)
+++ SIGNAL_CASE(cont)
+++ SIGNAL_CASE(stop)
+++ SIGNAL_CASE(terminal_stop)
+++ SIGNAL_CASE(terminal_in)
+++ SIGNAL_CASE(terminal_out)
+++ SIGNAL_CASE(bus)
+++#ifdef SIGPOLL
+++ SIGNAL_CASE(poll)
+++#endif
+++ SIGNAL_CASE(profiler)
+++ SIGNAL_CASE(system_call)
+++ SIGNAL_CASE(trap)
+++ SIGNAL_CASE(urgent_data)
+++ SIGNAL_CASE(virtual_timer)
+++ SIGNAL_CASE(cpu_limit)
+++ SIGNAL_CASE(file_size_limit)
+++ default: return "unknown";
+++ }
+++#undef SIGNAL_CASE
+++ }
+++ std::error_condition default_error_condition(int ev) const noexcept override
+++ { return {ev, *this}; }
+++ };
+++} // anonymous namespace
+++
+++namespace sig {
+++namespace errors {
+++
+++ std::error_code make_error_code(error_code_enum e)
+++ {
+++ return {e, sig_category()};
+++ }
+++
+++ std::error_condition make_error_condition(error_code_enum e)
+++ {
+++ return {e, sig_category()};
+++ }
+++
+++} // namespace errors
+++
+++std::error_category& sig_category()
+++{
+++ static signal_error_category signal_category;
+++ return signal_category;
+++}
+++
+++#ifdef _WIN32
+++
+++namespace {
+++ sig::errors::error_code_enum map_exception_code(int const ev)
+++ {
+++ switch (ev)
+++ {
+++ case seh_errors::error_code_enum::access_violation:
+++ case seh_errors::error_code_enum::array_bounds_exceeded:
+++ case seh_errors::error_code_enum::guard_page:
+++ case seh_errors::error_code_enum::stack_overflow:
+++ case seh_errors::error_code_enum::flt_stack_check:
+++ case seh_errors::error_code_enum::in_page_error:
+++ return sig::errors::segmentation;
+++ case seh_errors::error_code_enum::breakpoint:
+++ case seh_errors::error_code_enum::single_step:
+++ return sig::errors::trap;
+++ case seh_errors::error_code_enum::datatype_misalignment:
+++ return sig::errors::bus;
+++ case seh_errors::error_code_enum::flt_denormal_operand:
+++ case seh_errors::error_code_enum::flt_divide_by_zero:
+++ case seh_errors::error_code_enum::flt_inexact_result:
+++ case seh_errors::error_code_enum::flt_invalid_operation:
+++ case seh_errors::error_code_enum::flt_overflow:
+++ case seh_errors::error_code_enum::flt_underflow:
+++ case seh_errors::error_code_enum::int_divide_by_zero:
+++ case seh_errors::error_code_enum::int_overflow:
+++ return sig::errors::arithmetic_exception;
+++ case seh_errors::error_code_enum::illegal_instruction:
+++ case seh_errors::error_code_enum::invalid_disposition:
+++ case seh_errors::error_code_enum::priv_instruction:
+++ case seh_errors::error_code_enum::noncontinuable_exception:
+++ case seh_errors::error_code_enum::status_unwind_consolidate:
+++ return sig::errors::illegal;
+++ case seh_errors::error_code_enum::invalid_handle:
+++ return sig::errors::pipe;
+++ default:
+++ return sig::errors::illegal;
+++ }
+++ }
+++
+++ struct seh_error_category : std::error_category
+++ {
+++ const char* name() const noexcept override
+++ { return "SEH"; }
+++ std::string message(int ev) const noexcept override
+++ {
+++#define SIGNAL_CASE(x) case sig::seh_errors::error_code_enum:: x: return #x;
+++ switch (ev)
+++ {
+++ SIGNAL_CASE(access_violation)
+++ SIGNAL_CASE(array_bounds_exceeded)
+++ SIGNAL_CASE(guard_page)
+++ SIGNAL_CASE(stack_overflow)
+++ SIGNAL_CASE(flt_stack_check)
+++ SIGNAL_CASE(in_page_error)
+++ SIGNAL_CASE(breakpoint)
+++ SIGNAL_CASE(single_step)
+++ SIGNAL_CASE(datatype_misalignment)
+++ SIGNAL_CASE(flt_denormal_operand)
+++ SIGNAL_CASE(flt_divide_by_zero)
+++ SIGNAL_CASE(flt_inexact_result)
+++ SIGNAL_CASE(flt_invalid_operation)
+++ SIGNAL_CASE(flt_overflow)
+++ SIGNAL_CASE(flt_underflow)
+++ SIGNAL_CASE(int_divide_by_zero)
+++ SIGNAL_CASE(int_overflow)
+++ SIGNAL_CASE(illegal_instruction)
+++ SIGNAL_CASE(invalid_disposition)
+++ SIGNAL_CASE(priv_instruction)
+++ SIGNAL_CASE(noncontinuable_exception)
+++ SIGNAL_CASE(status_unwind_consolidate)
+++ SIGNAL_CASE(invalid_handle)
+++ default: return "unknown";
+++ }
+++#undef SIGNAL_CASE
+++ }
+++ std::error_condition default_error_condition(int ev) const noexcept override
+++ { return std::error_condition(map_exception_code(ev), sig_category()); }
+++ };
+++} // anonymous namespace
+++
+++namespace seh_errors {
+++
+++ std::error_code make_error_code(error_code_enum e)
+++ {
+++ return {static_cast<int>(e), seh_category()};
+++ }
+++
+++} // namespace errors
+++
+++std::error_category& seh_category()
+++{
+++ static seh_error_category seh_category;
+++ return seh_category;
+++}
+++
+++#endif
+++
+++} // namespace sig
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/deps/try_signal/signal_error_code.hpp
++@@ -0,0 +1,162 @@
+++/*
+++
+++Copyright (c) 2016, Arvid Norberg
+++All rights reserved.
+++
+++Redistribution and use in source and binary forms, with or without
+++modification, are permitted provided that the following conditions
+++are met:
+++
+++ * Redistributions of source code must retain the above copyright
+++ notice, this list of conditions and the following disclaimer.
+++ * Redistributions in binary form must reproduce the above copyright
+++ notice, this list of conditions and the following disclaimer in
+++ the documentation and/or other materials provided with the distribution.
+++ * Neither the name of the author nor the names of its
+++ contributors may be used to endorse or promote products derived
+++ from this software without specific prior written permission.
+++
+++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+++POSSIBILITY OF SUCH DAMAGE.
+++
+++*/
+++
+++#ifndef SIGNAL_ERROR_CODE_HPP_INCLUDED
+++#define SIGNAL_ERROR_CODE_HPP_INCLUDED
+++
+++#include <signal.h>
+++#include <system_error>
+++
+++#ifdef _WIN32
+++#ifndef WIN32_LEAN_AND_MEAN
+++#define WIN32_LEAN_AND_MEAN
+++#endif
+++#include <windows.h>
+++
+++#ifdef __GNUC__
+++#include <excpt.h>
+++#else
+++#include <eh.h>
+++#endif
+++#endif
+++
+++namespace sig {
+++namespace errors {
+++
+++#ifdef _WIN32
+++#define SIG_ENUM(name, sig) name,
+++#else
+++#define SIG_ENUM(name, sig) name = sig,
+++#endif
+++
+++ enum error_code_enum: int
+++ {
+++ SIG_ENUM(abort, SIGABRT)
+++ SIG_ENUM(alarm, SIGALRM)
+++ SIG_ENUM(arithmetic_exception, SIGFPE)
+++ SIG_ENUM(hangup, SIGHUP)
+++ SIG_ENUM(illegal, SIGILL)
+++ SIG_ENUM(interrupt, SIGINT)
+++ SIG_ENUM(kill, SIGKILL)
+++ SIG_ENUM(pipe, SIGPIPE)
+++ SIG_ENUM(quit, SIGQUIT)
+++ SIG_ENUM(segmentation, SIGSEGV)
+++ SIG_ENUM(terminate, SIGTERM)
+++ SIG_ENUM(user1, SIGUSR1)
+++ SIG_ENUM(user2, SIGUSR2)
+++ SIG_ENUM(child, SIGCHLD)
+++ SIG_ENUM(cont, SIGCONT)
+++ SIG_ENUM(stop, SIGSTOP)
+++ SIG_ENUM(terminal_stop, SIGTSTP)
+++ SIG_ENUM(terminal_in, SIGTTIN)
+++ SIG_ENUM(terminal_out, SIGTTOU)
+++ SIG_ENUM(bus, SIGBUS)
+++#ifdef SIGPOLL
+++ SIG_ENUM(poll, SIGPOLL)
+++#endif
+++ SIG_ENUM(profiler, SIGPROF)
+++ SIG_ENUM(system_call, SIGSYS)
+++ SIG_ENUM(trap, SIGTRAP)
+++ SIG_ENUM(urgent_data, SIGURG)
+++ SIG_ENUM(virtual_timer, SIGVTALRM)
+++ SIG_ENUM(cpu_limit, SIGXCPU)
+++ SIG_ENUM(file_size_limit, SIGXFSZ)
+++ };
+++
+++#undef SIG_ENUM
+++
+++ std::error_code make_error_code(error_code_enum e);
+++ std::error_condition make_error_condition(error_code_enum e);
+++
+++} // namespace errors
+++
+++std::error_category& sig_category();
+++
+++#ifdef _WIN32
+++namespace seh_errors {
+++
+++ // standard error codes are "int", the win32 exceptions are DWORD (i.e.
+++ // unsigned int). We coerce them into int here for compatibility, and we're
+++ // not concerned about their arithmetic
+++ enum error_code_enum: int
+++ {
+++ access_violation = int(EXCEPTION_ACCESS_VIOLATION),
+++ array_bounds_exceeded = int(EXCEPTION_ARRAY_BOUNDS_EXCEEDED),
+++ guard_page = int(EXCEPTION_GUARD_PAGE),
+++ stack_overflow = int(EXCEPTION_STACK_OVERFLOW),
+++ flt_stack_check = int(EXCEPTION_FLT_STACK_CHECK),
+++ in_page_error = int(EXCEPTION_IN_PAGE_ERROR),
+++ breakpoint = int(EXCEPTION_BREAKPOINT),
+++ single_step = int(EXCEPTION_SINGLE_STEP),
+++ datatype_misalignment = int(EXCEPTION_DATATYPE_MISALIGNMENT),
+++ flt_denormal_operand = int(EXCEPTION_FLT_DENORMAL_OPERAND),
+++ flt_divide_by_zero = int(EXCEPTION_FLT_DIVIDE_BY_ZERO),
+++ flt_inexact_result = int(EXCEPTION_FLT_INEXACT_RESULT),
+++ flt_invalid_operation = int(EXCEPTION_FLT_INVALID_OPERATION),
+++ flt_overflow = int(EXCEPTION_FLT_OVERFLOW),
+++ flt_underflow = int(EXCEPTION_FLT_UNDERFLOW),
+++ int_divide_by_zero = int(EXCEPTION_INT_DIVIDE_BY_ZERO),
+++ int_overflow = int(EXCEPTION_INT_OVERFLOW),
+++ illegal_instruction = int(EXCEPTION_ILLEGAL_INSTRUCTION),
+++ invalid_disposition = int(EXCEPTION_INVALID_DISPOSITION),
+++ priv_instruction = int(EXCEPTION_PRIV_INSTRUCTION),
+++ noncontinuable_exception = int(EXCEPTION_NONCONTINUABLE_EXCEPTION),
+++ status_unwind_consolidate = int(STATUS_UNWIND_CONSOLIDATE),
+++ invalid_handle = int(EXCEPTION_INVALID_HANDLE),
+++ };
+++
+++ std::error_code make_error_code(error_code_enum e);
+++}
+++
+++std::error_category& seh_category();
+++
+++#endif // _WIN32
+++
+++} // namespace sig
+++
+++namespace std
+++{
+++template<>
+++struct is_error_code_enum<sig::errors::error_code_enum> : std::true_type {};
+++
+++template<>
+++struct is_error_condition_enum<sig::errors::error_code_enum> : std::true_type {};
+++
+++#ifdef _WIN32
+++template<>
+++struct is_error_code_enum<sig::seh_errors::error_code_enum> : std::true_type {};
+++#endif
+++
+++} // namespace std
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/deps/try_signal/test.cpp
++@@ -0,0 +1,47 @@
+++#include <stdexcept>
+++#include <array>
+++#include <cstring> // for memcpy
+++
+++#include "try_signal.hpp"
+++
+++int main()
+++{
+++ char const buf[] = "test...test";
+++ char dest[sizeof(buf)];
+++
+++ {
+++ sig::try_signal([&]{
+++ std::memcpy(dest, buf, sizeof(buf));
+++ });
+++ if (!std::equal(buf, buf + sizeof(buf), dest)) {
+++ fprintf(stderr, "ERROR: buffer not copied correctly\n");
+++ return 1;
+++ }
+++ }
+++
+++ try {
+++ void* invalid_pointer = nullptr;
+++ sig::try_signal([&]{
+++ std::memcpy(dest, buf, sizeof(buf));
+++ std::memcpy(dest, invalid_pointer, sizeof(buf));
+++ });
+++ }
+++ catch (std::system_error const& e)
+++ {
+++ if (e.code() != std::error_condition(sig::errors::segmentation)) {
+++ fprintf(stderr, "ERROR: expected segmentaiton violation error\n");
+++ }
+++ else {
+++ fprintf(stderr, "OK\n");
+++ }
+++ fprintf(stderr, "exited with expected system_error exception: %s\n", e.what());
+++
+++ // we expect this to happen, so return 0
+++ return e.code() == std::error_condition(sig::errors::segmentation) ? 0 : 1;
+++ }
+++
+++ // return non-zero here because we don't expect this
+++ fprintf(stderr, "ERROR: expected exit through exception\n");
+++ return 1;
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/deps/try_signal/try_signal.cpp
++@@ -0,0 +1,144 @@
+++/*
+++
+++Copyright (c) 2016, Arvid Norberg
+++All rights reserved.
+++
+++Redistribution and use in source and binary forms, with or without
+++modification, are permitted provided that the following conditions
+++are met:
+++
+++ * Redistributions of source code must retain the above copyright
+++ notice, this list of conditions and the following disclaimer.
+++ * Redistributions in binary form must reproduce the above copyright
+++ notice, this list of conditions and the following disclaimer in
+++ the documentation and/or other materials provided with the distribution.
+++ * Neither the name of the author nor the names of its
+++ contributors may be used to endorse or promote products derived
+++ from this software without specific prior written permission.
+++
+++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+++POSSIBILITY OF SUCH DAMAGE.
+++
+++*/
+++
+++#include <cassert>
+++#include <system_error>
+++#include <atomic>
+++#include <csetjmp>
+++#include <csignal>
+++
+++#include "try_signal.hpp"
+++
+++#if !defined _WIN32
+++// linux
+++
+++namespace sig {
+++namespace detail {
+++
+++namespace {
+++thread_local sigjmp_buf* jmpbuf = nullptr;
+++}
+++
+++std::atomic_flag once = ATOMIC_FLAG_INIT;
+++
+++scoped_jmpbuf::scoped_jmpbuf(sigjmp_buf* ptr)
+++{
+++ _previous_ptr = jmpbuf;
+++ jmpbuf = ptr;
+++ std::atomic_signal_fence(std::memory_order_release);
+++}
+++
+++scoped_jmpbuf::~scoped_jmpbuf() { jmpbuf = _previous_ptr; }
+++
+++void handler(int const signo, siginfo_t*, void*)
+++{
+++ std::atomic_signal_fence(std::memory_order_acquire);
+++ if (jmpbuf)
+++ siglongjmp(*jmpbuf, signo);
+++
+++ // this signal was not caused within the scope of a try_signal object,
+++ // invoke the default handler
+++ signal(signo, SIG_DFL);
+++ raise(signo);
+++}
+++
+++void setup_handler()
+++{
+++ struct sigaction sa;
+++ sa.sa_sigaction = &sig::detail::handler;
+++ sigemptyset(&sa.sa_mask);
+++ sa.sa_flags = SA_SIGINFO;
+++ sigaction(SIGSEGV, &sa, nullptr);
+++ sigaction(SIGBUS, &sa, nullptr);
+++}
+++
+++} // detail namespace
+++} // sig namespace
+++
+++#elif __GNUC__
+++// mingw
+++
+++#ifndef WIN32_LEAN_AND_MEAN
+++#define WIN32_LEAN_AND_MEAN
+++#endif
+++#include <windows.h>
+++
+++namespace sig {
+++namespace detail {
+++
+++thread_local jmp_buf* jmpbuf = nullptr;
+++
+++long CALLBACK handler(EXCEPTION_POINTERS* pointers)
+++{
+++ std::atomic_signal_fence(std::memory_order_acquire);
+++ if (jmpbuf)
+++ longjmp(*jmpbuf, pointers->ExceptionRecord->ExceptionCode);
+++ return EXCEPTION_CONTINUE_SEARCH;
+++}
+++
+++scoped_handler::scoped_handler(jmp_buf* ptr)
+++{
+++ _previous_ptr = jmpbuf;
+++ jmpbuf = ptr;
+++ std::atomic_signal_fence(std::memory_order_release);
+++ _handle = AddVectoredExceptionHandler(1, sig::detail::handler);
+++}
+++scoped_handler::~scoped_handler()
+++{
+++ RemoveVectoredExceptionHandler(_handle);
+++ jmpbuf = _previous_ptr;
+++}
+++
+++} // detail namespace
+++} // sig namespace
+++
+++#else
+++// windows
+++
+++#include <winnt.h> // for EXCEPTION_*
+++
+++namespace sig {
+++namespace detail {
+++
+++ // these are the kinds of SEH exceptions we'll translate into C++ exceptions
+++ bool catch_error(int const code)
+++ {
+++ return code == EXCEPTION_IN_PAGE_ERROR
+++ || code == EXCEPTION_ACCESS_VIOLATION
+++ || code == EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
+++ }
+++} // detail namespace
+++} // namespace sig
+++
+++#endif // _WIN32
+++
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/deps/try_signal/try_signal.hpp
++@@ -0,0 +1,49 @@
+++/*
+++
+++Copyright (c) 2017, Arvid Norberg
+++All rights reserved.
+++
+++Redistribution and use in source and binary forms, with or without
+++modification, are permitted provided that the following conditions
+++are met:
+++
+++ * Redistributions of source code must retain the above copyright
+++ notice, this list of conditions and the following disclaimer.
+++ * Redistributions in binary form must reproduce the above copyright
+++ notice, this list of conditions and the following disclaimer in
+++ the documentation and/or other materials provided with the distribution.
+++ * Neither the name of the author nor the names of its
+++ contributors may be used to endorse or promote products derived
+++ from this software without specific prior written permission.
+++
+++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+++POSSIBILITY OF SUCH DAMAGE.
+++
+++*/
+++
+++#ifndef TRY_SIGNAL_HPP_INCLUDED
+++#define TRY_SIGNAL_HPP_INCLUDED
+++
+++#if !defined _WIN32
+++// linux
+++#include "try_signal_posix.hpp"
+++#elif __GNUC__
+++// mingw
+++#include "try_signal_mingw.hpp"
+++#else
+++// windows
+++#include "try_signal_msvc.hpp"
+++#endif
+++
+++
+++#endif // TRY_SIGNAL_HPP_INCLUDED
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/deps/try_signal/try_signal_mingw.hpp
++@@ -0,0 +1,78 @@
+++/*
+++
+++Copyright (c) 2017, Arvid Norberg
+++All rights reserved.
+++
+++Redistribution and use in source and binary forms, with or without
+++modification, are permitted provided that the following conditions
+++are met:
+++
+++ * Redistributions of source code must retain the above copyright
+++ notice, this list of conditions and the following disclaimer.
+++ * Redistributions in binary form must reproduce the above copyright
+++ notice, this list of conditions and the following disclaimer in
+++ the documentation and/or other materials provided with the distribution.
+++ * Neither the name of the author nor the names of its
+++ contributors may be used to endorse or promote products derived
+++ from this software without specific prior written permission.
+++
+++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+++POSSIBILITY OF SUCH DAMAGE.
+++
+++*/
+++
+++#ifndef TRY_SIGNAL_MINGW_HPP_INCLUDED
+++#define TRY_SIGNAL_MINGW_HPP_INCLUDED
+++
+++#include "signal_error_code.hpp"
+++
+++#include <setjmp.h> // for jmp_buf
+++
+++#ifndef WIN32_LEAN_AND_MEAN
+++#define WIN32_LEAN_AND_MEAN
+++#endif
+++#include <windows.h>
+++
+++namespace sig {
+++namespace detail {
+++
+++struct scoped_handler
+++{
+++ scoped_handler(jmp_buf* ptr);
+++ ~scoped_handler();
+++ scoped_handler(scoped_handler const&) = delete;
+++ scoped_handler& operator=(scoped_handler const&) = delete;
+++private:
+++ void* _handle;
+++ jmp_buf* _previous_ptr;
+++};
+++
+++} // detail namespace
+++
+++template <typename Fun>
+++void try_signal(Fun&& f)
+++{
+++ jmp_buf buf;
+++ int const code = setjmp(buf);
+++ // set the thread local jmpbuf pointer, and make sure it's cleared when we
+++ // leave the scope
+++ sig::detail::scoped_handler scope(&buf);
+++ if (code != 0)
+++ throw std::system_error(std::error_code(code, seh_category()));
+++
+++ f();
+++}
+++
+++} // sig namespace
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/deps/try_signal/try_signal_msvc.hpp
++@@ -0,0 +1,61 @@
+++/*
+++
+++Copyright (c) 2017, Arvid Norberg
+++All rights reserved.
+++
+++Redistribution and use in source and binary forms, with or without
+++modification, are permitted provided that the following conditions
+++are met:
+++
+++ * Redistributions of source code must retain the above copyright
+++ notice, this list of conditions and the following disclaimer.
+++ * Redistributions in binary form must reproduce the above copyright
+++ notice, this list of conditions and the following disclaimer in
+++ the documentation and/or other materials provided with the distribution.
+++ * Neither the name of the author nor the names of its
+++ contributors may be used to endorse or promote products derived
+++ from this software without specific prior written permission.
+++
+++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+++POSSIBILITY OF SUCH DAMAGE.
+++
+++*/
+++
+++#ifndef TRY_SIGNAL_MSVC_HPP_INCLUDED
+++#define TRY_SIGNAL_MSVC_HPP_INCLUDED
+++
+++#include "signal_error_code.hpp"
+++
+++namespace sig {
+++namespace detail {
+++
+++bool catch_error(int const code);
+++
+++} // detail namespace
+++
+++template <typename Fun>
+++void try_signal(Fun&& f)
+++{
+++ __try
+++ {
+++ f();
+++ }
+++ __except (detail::catch_error(GetExceptionCode()))
+++ {
+++ throw std::system_error(std::error_code(GetExceptionCode(), seh_category()));
+++ }
+++}
+++
+++} // sig namespace
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/deps/try_signal/try_signal_posix.hpp
++@@ -0,0 +1,82 @@
+++/*
+++
+++Copyright (c) 2017, Arvid Norberg
+++All rights reserved.
+++
+++Redistribution and use in source and binary forms, with or without
+++modification, are permitted provided that the following conditions
+++are met:
+++
+++ * Redistributions of source code must retain the above copyright
+++ notice, this list of conditions and the following disclaimer.
+++ * Redistributions in binary form must reproduce the above copyright
+++ notice, this list of conditions and the following disclaimer in
+++ the documentation and/or other materials provided with the distribution.
+++ * Neither the name of the author nor the names of its
+++ contributors may be used to endorse or promote products derived
+++ from this software without specific prior written permission.
+++
+++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+++POSSIBILITY OF SUCH DAMAGE.
+++
+++*/
+++
+++#ifndef TRY_SIGNAL_POSIX_HPP_INCLUDED
+++#define TRY_SIGNAL_POSIX_HPP_INCLUDED
+++
+++#include "signal_error_code.hpp"
+++#include <setjmp.h> // for sigjmp_buf
+++#include <atomic>
+++
+++namespace sig {
+++
+++namespace detail {
+++
+++extern std::atomic_flag once;
+++
+++struct scoped_jmpbuf
+++{
+++ explicit scoped_jmpbuf(sigjmp_buf* ptr);
+++ ~scoped_jmpbuf();
+++ scoped_jmpbuf(scoped_jmpbuf const&) = delete;
+++ scoped_jmpbuf& operator=(scoped_jmpbuf const&) = delete;
+++private:
+++ sigjmp_buf* _previous_ptr;
+++};
+++
+++void handler(int const signo, siginfo_t* si, void*);
+++void setup_handler();
+++
+++} // detail namespace
+++
+++template <typename Fun>
+++void try_signal(Fun&& f)
+++{
+++ if (sig::detail::once.test_and_set() == false) {
+++ sig::detail::setup_handler();
+++ }
+++
+++ sigjmp_buf buf;
+++ int const sig = sigsetjmp(buf, 1);
+++ // set the thread local jmpbuf pointer, and make sure it's cleared when we
+++ // leave the scope
+++ sig::detail::scoped_jmpbuf scope(&buf);
+++ if (sig != 0)
+++ throw std::system_error(static_cast<sig::errors::error_code_enum>(sig));
+++
+++ f();
+++}
+++
+++}
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/CMakeLists.txt
++@@ -0,0 +1,61 @@
+++project(libsimulator)
+++cmake_minimum_required(VERSION 2.8.7)
+++
+++set(SRC_DIR src)
+++set(TEST_SRC_DIR test)
+++set(INCLUDE_DIR include)
+++set(CMAKE_CXX_STANDARD 14)
+++set(CMAKE_CXX_STANDARD_REQUIRED ON)
+++
+++# Boost.System is header-only (since Boost 1.69), so we only need the Boost
+++# headers. Requesting the "system" component fails with recent Boost releases
+++# that no longer ship a boost_system CMake config file.
+++find_package(Boost REQUIRED)
+++find_package(Threads REQUIRED)
+++
+++set(SIMULATOR_SRC_FILES
+++ ${SRC_DIR}/acceptor.cpp
+++ ${SRC_DIR}/high_resolution_timer.cpp
+++ ${SRC_DIR}/io_service.cpp
+++ ${SRC_DIR}/resolver.cpp
+++ ${SRC_DIR}/sink_forwarder.cpp
+++ ${SRC_DIR}/udp_socket.cpp
+++ ${SRC_DIR}/default_config.cpp
+++ ${SRC_DIR}/http_proxy.cpp
+++ ${SRC_DIR}/pcap.cpp
+++ ${SRC_DIR}/simulation.cpp
+++ ${SRC_DIR}/socks_server.cpp
+++ ${SRC_DIR}/high_resolution_clock.cpp
+++ ${SRC_DIR}/http_server.cpp
+++ ${SRC_DIR}/queue.cpp
+++ ${SRC_DIR}/simulator.cpp
+++ ${SRC_DIR}/tcp_socket.cpp
+++ ${SRC_DIR}/nat.cpp
+++)
+++
+++add_library(simulator ${SIMULATOR_SRC_FILES})
+++target_include_directories(simulator PUBLIC ${INCLUDE_DIR})
+++target_link_libraries(simulator PUBLIC Boost::boost)
+++
+++if(WIN32)
+++ target_link_libraries(simulator PRIVATE ws2_32)
+++endif()
+++
+++enable_testing()
+++
+++function(define_test)
+++ set(NAME ${ARGV0})
+++ add_executable(${NAME} ${TEST_SRC_DIR}/${NAME}.cpp ${TEST_SRC_DIR}/main.cpp)
+++ target_link_libraries(${NAME} simulator)
+++ target_link_libraries(${NAME} Threads::Threads)
+++ add_test(NAME ${NAME} COMMAND ${NAME})
+++endfunction()
+++
+++define_test(acceptor)
+++define_test(multi_accept)
+++define_test(multi_homed)
+++define_test(null_buffers)
+++define_test(parse_request)
+++define_test(resolver)
+++define_test(timer)
+++define_test(udp_socket)
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/Jamfile
++@@ -0,0 +1,136 @@
+++# This Jamfile requires boost-build v2 to build.
+++
+++import path ;
+++import modules ;
+++import os ;
+++import testing ;
+++
+++BOOST_ROOT = [ modules.peek : BOOST_ROOT ] ;
+++
+++ECHO "BOOST_ROOT =" $(BOOST_ROOT) ;
+++ECHO "OS =" [ os.name ] ;
+++
+++lib wsock32 : : <name>wsock32 <link>shared ;
+++lib ws2_32 : : <name>ws2_32 <link>shared ;
+++
+++if $(BOOST_ROOT)
+++{
+++ use-project /boost : $(BOOST_ROOT) ;
+++ alias boost_system : /boost/system//boost_system ;
+++}
+++else
+++{
+++ local boost-lib-search-path =
+++ <search>/usr/local/opt/boost/lib
+++ <search>/opt/homebrew/lib
+++ ;
+++
+++ local boost-include-path =
+++ <include>/usr/local/opt/boost/include
+++ <include>/opt/homebrew/include
+++ ;
+++
+++ # boost_system is a header-only library now, but we still need to find the boost headers
+++ alias boost_system : : : : $(boost-include-path) ;
+++}
+++
+++SOURCES =
+++ simulator
+++ simulation
+++ io_service
+++ high_resolution_timer
+++ high_resolution_clock
+++ tcp_socket
+++ udp_socket
+++ queue
+++ acceptor
+++ default_config
+++ http_server
+++ socks_server
+++ resolver
+++ http_proxy
+++ sink_forwarder
+++ pcap
+++ nat
+++ ;
+++
+++lib simulator
+++ : # sources
+++ src/$(SOURCES).cpp
+++
+++ : # requirements
+++ <include>include
+++ <library>boost_system
+++ <target-os>windows:<library>ws2_32
+++ <target-os>windows:<library>wsock32
+++ <threading>multi
+++
+++ <link>shared:<define>SIMULATOR_BUILDING_SHARED
+++ <define>_CRT_SECURE_NO_WARNINGS
+++
+++ # https://github.com/chriskohlhoff/asio/issues/290#issuecomment-377727614
+++ <define>_SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING
+++
+++ <define>BOOST_ASIO_DISABLE_BOOST_DATE_TIME
+++ <define>BOOST_ASIO_HAS_MOVE
+++ <define>BOOST_ASIO_ENABLE_CANCELIO
+++
+++ # make sure asio uses std::chrono
+++ <define>BOOST_ASIO_HAS_STD_CHRONO
+++
+++ # io_executor only implements the legacy (Networking TS v1) executor
+++ # concept: this falls any_io_executor back to boost::asio::executor,
+++ # which it can wrap, so boost::asio::ssl::stream's bookkeeping timers
+++ # work for consumers that include simulator/ssl.hpp.
+++ <define>BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT
+++
+++ # disable auto-link
+++ <define>BOOST_ALL_NO_LIB
+++
+++ : # default build
+++ <warnings>all
+++ <warnings-as-errors>on
+++ # boost.asio has a global tss_ptr which is the head of a
+++ # linked list of all invocations of run on that thread. This
+++ # determines whether dispatch() will run the handler immediately
+++ # not. The simulator relies on this. On windows each DLL will have
+++ # its own copy of this variable, effectively causing a deadlock
+++ # in the simulator. So, default to static linking
+++ <link>static
+++
+++ : # usage requirements
+++ <define>BOOST_ASIO_DISABLE_BOOST_DATE_TIME
+++ <define>BOOST_ASIO_HAS_MOVE
+++ <define>BOOST_ASIO_ENABLE_CANCELIO
+++ <define>BOOST_ASIO_USE_TS_EXECUTOR_AS_DEFAULT
+++ <threading>multi
+++ <include>include
+++ <link>shared:<define>SIMULATOR_LINKING_SHARED
+++
+++ # https://github.com/chriskohlhoff/asio/issues/290#issuecomment-377727614
+++ <define>_SILENCE_CXX17_ALLOCATOR_VOID_DEPRECATION_WARNING
+++ ;
+++
+++project
+++ : requirements
+++ <library>simulator
+++ # disable auto-link
+++ <define>BOOST_ALL_NO_LIB
+++ : default-build
+++ <link>static
+++ <threading>multi
+++ <cxxstd>14
+++ ;
+++
+++test-suite simulator-tests : [ run
+++ test/main.cpp
+++ test/resolver.cpp
+++ test/multi_homed.cpp
+++ test/timer.cpp
+++ test/acceptor.cpp
+++ test/multi_accept.cpp
+++ test/null_buffers.cpp
+++ test/udp_socket.cpp
+++ test/parse_request.cpp
+++ ] ;
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/LICENSE
++@@ -0,0 +1,675 @@
+++ GNU GENERAL PUBLIC LICENSE
+++ Version 3, 29 June 2007
+++
+++ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+++ Everyone is permitted to copy and distribute verbatim copies
+++ of this license document, but changing it is not allowed.
+++
+++ Preamble
+++
+++ The GNU General Public License is a free, copyleft license for
+++software and other kinds of works.
+++
+++ The licenses for most software and other practical works are designed
+++to take away your freedom to share and change the works. By contrast,
+++the GNU General Public License is intended to guarantee your freedom to
+++share and change all versions of a program--to make sure it remains free
+++software for all its users. We, the Free Software Foundation, use the
+++GNU General Public License for most of our software; it applies also to
+++any other work released this way by its authors. You can apply it to
+++your programs, too.
+++
+++ When we speak of free software, we are referring to freedom, not
+++price. Our General Public Licenses are designed to make sure that you
+++have the freedom to distribute copies of free software (and charge for
+++them if you wish), that you receive source code or can get it if you
+++want it, that you can change the software or use pieces of it in new
+++free programs, and that you know you can do these things.
+++
+++ To protect your rights, we need to prevent others from denying you
+++these rights or asking you to surrender the rights. Therefore, you have
+++certain responsibilities if you distribute copies of the software, or if
+++you modify it: responsibilities to respect the freedom of others.
+++
+++ For example, if you distribute copies of such a program, whether
+++gratis or for a fee, you must pass on to the recipients the same
+++freedoms that you received. You must make sure that they, too, receive
+++or can get the source code. And you must show them these terms so they
+++know their rights.
+++
+++ Developers that use the GNU GPL protect your rights with two steps:
+++(1) assert copyright on the software, and (2) offer you this License
+++giving you legal permission to copy, distribute and/or modify it.
+++
+++ For the developers' and authors' protection, the GPL clearly explains
+++that there is no warranty for this free software. For both users' and
+++authors' sake, the GPL requires that modified versions be marked as
+++changed, so that their problems will not be attributed erroneously to
+++authors of previous versions.
+++
+++ Some devices are designed to deny users access to install or run
+++modified versions of the software inside them, although the manufacturer
+++can do so. This is fundamentally incompatible with the aim of
+++protecting users' freedom to change the software. The systematic
+++pattern of such abuse occurs in the area of products for individuals to
+++use, which is precisely where it is most unacceptable. Therefore, we
+++have designed this version of the GPL to prohibit the practice for those
+++products. If such problems arise substantially in other domains, we
+++stand ready to extend this provision to those domains in future versions
+++of the GPL, as needed to protect the freedom of users.
+++
+++ Finally, every program is threatened constantly by software patents.
+++States should not allow patents to restrict development and use of
+++software on general-purpose computers, but in those that do, we wish to
+++avoid the special danger that patents applied to a free program could
+++make it effectively proprietary. To prevent this, the GPL assures that
+++patents cannot be used to render the program non-free.
+++
+++ The precise terms and conditions for copying, distribution and
+++modification follow.
+++
+++ TERMS AND CONDITIONS
+++
+++ 0. Definitions.
+++
+++ "This License" refers to version 3 of the GNU General Public License.
+++
+++ "Copyright" also means copyright-like laws that apply to other kinds of
+++works, such as semiconductor masks.
+++
+++ "The Program" refers to any copyrightable work licensed under this
+++License. Each licensee is addressed as "you". "Licensees" and
+++"recipients" may be individuals or organizations.
+++
+++ To "modify" a work means to copy from or adapt all or part of the work
+++in a fashion requiring copyright permission, other than the making of an
+++exact copy. The resulting work is called a "modified version" of the
+++earlier work or a work "based on" the earlier work.
+++
+++ A "covered work" means either the unmodified Program or a work based
+++on the Program.
+++
+++ To "propagate" a work means to do anything with it that, without
+++permission, would make you directly or secondarily liable for
+++infringement under applicable copyright law, except executing it on a
+++computer or modifying a private copy. Propagation includes copying,
+++distribution (with or without modification), making available to the
+++public, and in some countries other activities as well.
+++
+++ To "convey" a work means any kind of propagation that enables other
+++parties to make or receive copies. Mere interaction with a user through
+++a computer network, with no transfer of a copy, is not conveying.
+++
+++ An interactive user interface displays "Appropriate Legal Notices"
+++to the extent that it includes a convenient and prominently visible
+++feature that (1) displays an appropriate copyright notice, and (2)
+++tells the user that there is no warranty for the work (except to the
+++extent that warranties are provided), that licensees may convey the
+++work under this License, and how to view a copy of this License. If
+++the interface presents a list of user commands or options, such as a
+++menu, a prominent item in the list meets this criterion.
+++
+++ 1. Source Code.
+++
+++ The "source code" for a work means the preferred form of the work
+++for making modifications to it. "Object code" means any non-source
+++form of a work.
+++
+++ A "Standard Interface" means an interface that either is an official
+++standard defined by a recognized standards body, or, in the case of
+++interfaces specified for a particular programming language, one that
+++is widely used among developers working in that language.
+++
+++ The "System Libraries" of an executable work include anything, other
+++than the work as a whole, that (a) is included in the normal form of
+++packaging a Major Component, but which is not part of that Major
+++Component, and (b) serves only to enable use of the work with that
+++Major Component, or to implement a Standard Interface for which an
+++implementation is available to the public in source code form. A
+++"Major Component", in this context, means a major essential component
+++(kernel, window system, and so on) of the specific operating system
+++(if any) on which the executable work runs, or a compiler used to
+++produce the work, or an object code interpreter used to run it.
+++
+++ The "Corresponding Source" for a work in object code form means all
+++the source code needed to generate, install, and (for an executable
+++work) run the object code and to modify the work, including scripts to
+++control those activities. However, it does not include the work's
+++System Libraries, or general-purpose tools or generally available free
+++programs which are used unmodified in performing those activities but
+++which are not part of the work. For example, Corresponding Source
+++includes interface definition files associated with source files for
+++the work, and the source code for shared libraries and dynamically
+++linked subprograms that the work is specifically designed to require,
+++such as by intimate data communication or control flow between those
+++subprograms and other parts of the work.
+++
+++ The Corresponding Source need not include anything that users
+++can regenerate automatically from other parts of the Corresponding
+++Source.
+++
+++ The Corresponding Source for a work in source code form is that
+++same work.
+++
+++ 2. Basic Permissions.
+++
+++ All rights granted under this License are granted for the term of
+++copyright on the Program, and are irrevocable provided the stated
+++conditions are met. This License explicitly affirms your unlimited
+++permission to run the unmodified Program. The output from running a
+++covered work is covered by this License only if the output, given its
+++content, constitutes a covered work. This License acknowledges your
+++rights of fair use or other equivalent, as provided by copyright law.
+++
+++ You may make, run and propagate covered works that you do not
+++convey, without conditions so long as your license otherwise remains
+++in force. You may convey covered works to others for the sole purpose
+++of having them make modifications exclusively for you, or provide you
+++with facilities for running those works, provided that you comply with
+++the terms of this License in conveying all material for which you do
+++not control copyright. Those thus making or running the covered works
+++for you must do so exclusively on your behalf, under your direction
+++and control, on terms that prohibit them from making any copies of
+++your copyrighted material outside their relationship with you.
+++
+++ Conveying under any other circumstances is permitted solely under
+++the conditions stated below. Sublicensing is not allowed; section 10
+++makes it unnecessary.
+++
+++ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+++
+++ No covered work shall be deemed part of an effective technological
+++measure under any applicable law fulfilling obligations under article
+++11 of the WIPO copyright treaty adopted on 20 December 1996, or
+++similar laws prohibiting or restricting circumvention of such
+++measures.
+++
+++ When you convey a covered work, you waive any legal power to forbid
+++circumvention of technological measures to the extent such circumvention
+++is effected by exercising rights under this License with respect to
+++the covered work, and you disclaim any intention to limit operation or
+++modification of the work as a means of enforcing, against the work's
+++users, your or third parties' legal rights to forbid circumvention of
+++technological measures.
+++
+++ 4. Conveying Verbatim Copies.
+++
+++ You may convey verbatim copies of the Program's source code as you
+++receive it, in any medium, provided that you conspicuously and
+++appropriately publish on each copy an appropriate copyright notice;
+++keep intact all notices stating that this License and any
+++non-permissive terms added in accord with section 7 apply to the code;
+++keep intact all notices of the absence of any warranty; and give all
+++recipients a copy of this License along with the Program.
+++
+++ You may charge any price or no price for each copy that you convey,
+++and you may offer support or warranty protection for a fee.
+++
+++ 5. Conveying Modified Source Versions.
+++
+++ You may convey a work based on the Program, or the modifications to
+++produce it from the Program, in the form of source code under the
+++terms of section 4, provided that you also meet all of these conditions:
+++
+++ a) The work must carry prominent notices stating that you modified
+++ it, and giving a relevant date.
+++
+++ b) The work must carry prominent notices stating that it is
+++ released under this License and any conditions added under section
+++ 7. This requirement modifies the requirement in section 4 to
+++ "keep intact all notices".
+++
+++ c) You must license the entire work, as a whole, under this
+++ License to anyone who comes into possession of a copy. This
+++ License will therefore apply, along with any applicable section 7
+++ additional terms, to the whole of the work, and all its parts,
+++ regardless of how they are packaged. This License gives no
+++ permission to license the work in any other way, but it does not
+++ invalidate such permission if you have separately received it.
+++
+++ d) If the work has interactive user interfaces, each must display
+++ Appropriate Legal Notices; however, if the Program has interactive
+++ interfaces that do not display Appropriate Legal Notices, your
+++ work need not make them do so.
+++
+++ A compilation of a covered work with other separate and independent
+++works, which are not by their nature extensions of the covered work,
+++and which are not combined with it such as to form a larger program,
+++in or on a volume of a storage or distribution medium, is called an
+++"aggregate" if the compilation and its resulting copyright are not
+++used to limit the access or legal rights of the compilation's users
+++beyond what the individual works permit. Inclusion of a covered work
+++in an aggregate does not cause this License to apply to the other
+++parts of the aggregate.
+++
+++ 6. Conveying Non-Source Forms.
+++
+++ You may convey a covered work in object code form under the terms
+++of sections 4 and 5, provided that you also convey the
+++machine-readable Corresponding Source under the terms of this License,
+++in one of these ways:
+++
+++ a) Convey the object code in, or embodied in, a physical product
+++ (including a physical distribution medium), accompanied by the
+++ Corresponding Source fixed on a durable physical medium
+++ customarily used for software interchange.
+++
+++ b) Convey the object code in, or embodied in, a physical product
+++ (including a physical distribution medium), accompanied by a
+++ written offer, valid for at least three years and valid for as
+++ long as you offer spare parts or customer support for that product
+++ model, to give anyone who possesses the object code either (1) a
+++ copy of the Corresponding Source for all the software in the
+++ product that is covered by this License, on a durable physical
+++ medium customarily used for software interchange, for a price no
+++ more than your reasonable cost of physically performing this
+++ conveying of source, or (2) access to copy the
+++ Corresponding Source from a network server at no charge.
+++
+++ c) Convey individual copies of the object code with a copy of the
+++ written offer to provide the Corresponding Source. This
+++ alternative is allowed only occasionally and noncommercially, and
+++ only if you received the object code with such an offer, in accord
+++ with subsection 6b.
+++
+++ d) Convey the object code by offering access from a designated
+++ place (gratis or for a charge), and offer equivalent access to the
+++ Corresponding Source in the same way through the same place at no
+++ further charge. You need not require recipients to copy the
+++ Corresponding Source along with the object code. If the place to
+++ copy the object code is a network server, the Corresponding Source
+++ may be on a different server (operated by you or a third party)
+++ that supports equivalent copying facilities, provided you maintain
+++ clear directions next to the object code saying where to find the
+++ Corresponding Source. Regardless of what server hosts the
+++ Corresponding Source, you remain obligated to ensure that it is
+++ available for as long as needed to satisfy these requirements.
+++
+++ e) Convey the object code using peer-to-peer transmission, provided
+++ you inform other peers where the object code and Corresponding
+++ Source of the work are being offered to the general public at no
+++ charge under subsection 6d.
+++
+++ A separable portion of the object code, whose source code is excluded
+++from the Corresponding Source as a System Library, need not be
+++included in conveying the object code work.
+++
+++ A "User Product" is either (1) a "consumer product", which means any
+++tangible personal property which is normally used for personal, family,
+++or household purposes, or (2) anything designed or sold for incorporation
+++into a dwelling. In determining whether a product is a consumer product,
+++doubtful cases shall be resolved in favor of coverage. For a particular
+++product received by a particular user, "normally used" refers to a
+++typical or common use of that class of product, regardless of the status
+++of the particular user or of the way in which the particular user
+++actually uses, or expects or is expected to use, the product. A product
+++is a consumer product regardless of whether the product has substantial
+++commercial, industrial or non-consumer uses, unless such uses represent
+++the only significant mode of use of the product.
+++
+++ "Installation Information" for a User Product means any methods,
+++procedures, authorization keys, or other information required to install
+++and execute modified versions of a covered work in that User Product from
+++a modified version of its Corresponding Source. The information must
+++suffice to ensure that the continued functioning of the modified object
+++code is in no case prevented or interfered with solely because
+++modification has been made.
+++
+++ If you convey an object code work under this section in, or with, or
+++specifically for use in, a User Product, and the conveying occurs as
+++part of a transaction in which the right of possession and use of the
+++User Product is transferred to the recipient in perpetuity or for a
+++fixed term (regardless of how the transaction is characterized), the
+++Corresponding Source conveyed under this section must be accompanied
+++by the Installation Information. But this requirement does not apply
+++if neither you nor any third party retains the ability to install
+++modified object code on the User Product (for example, the work has
+++been installed in ROM).
+++
+++ The requirement to provide Installation Information does not include a
+++requirement to continue to provide support service, warranty, or updates
+++for a work that has been modified or installed by the recipient, or for
+++the User Product in which it has been modified or installed. Access to a
+++network may be denied when the modification itself materially and
+++adversely affects the operation of the network or violates the rules and
+++protocols for communication across the network.
+++
+++ Corresponding Source conveyed, and Installation Information provided,
+++in accord with this section must be in a format that is publicly
+++documented (and with an implementation available to the public in
+++source code form), and must require no special password or key for
+++unpacking, reading or copying.
+++
+++ 7. Additional Terms.
+++
+++ "Additional permissions" are terms that supplement the terms of this
+++License by making exceptions from one or more of its conditions.
+++Additional permissions that are applicable to the entire Program shall
+++be treated as though they were included in this License, to the extent
+++that they are valid under applicable law. If additional permissions
+++apply only to part of the Program, that part may be used separately
+++under those permissions, but the entire Program remains governed by
+++this License without regard to the additional permissions.
+++
+++ When you convey a copy of a covered work, you may at your option
+++remove any additional permissions from that copy, or from any part of
+++it. (Additional permissions may be written to require their own
+++removal in certain cases when you modify the work.) You may place
+++additional permissions on material, added by you to a covered work,
+++for which you have or can give appropriate copyright permission.
+++
+++ Notwithstanding any other provision of this License, for material you
+++add to a covered work, you may (if authorized by the copyright holders of
+++that material) supplement the terms of this License with terms:
+++
+++ a) Disclaiming warranty or limiting liability differently from the
+++ terms of sections 15 and 16 of this License; or
+++
+++ b) Requiring preservation of specified reasonable legal notices or
+++ author attributions in that material or in the Appropriate Legal
+++ Notices displayed by works containing it; or
+++
+++ c) Prohibiting misrepresentation of the origin of that material, or
+++ requiring that modified versions of such material be marked in
+++ reasonable ways as different from the original version; or
+++
+++ d) Limiting the use for publicity purposes of names of licensors or
+++ authors of the material; or
+++
+++ e) Declining to grant rights under trademark law for use of some
+++ trade names, trademarks, or service marks; or
+++
+++ f) Requiring indemnification of licensors and authors of that
+++ material by anyone who conveys the material (or modified versions of
+++ it) with contractual assumptions of liability to the recipient, for
+++ any liability that these contractual assumptions directly impose on
+++ those licensors and authors.
+++
+++ All other non-permissive additional terms are considered "further
+++restrictions" within the meaning of section 10. If the Program as you
+++received it, or any part of it, contains a notice stating that it is
+++governed by this License along with a term that is a further
+++restriction, you may remove that term. If a license document contains
+++a further restriction but permits relicensing or conveying under this
+++License, you may add to a covered work material governed by the terms
+++of that license document, provided that the further restriction does
+++not survive such relicensing or conveying.
+++
+++ If you add terms to a covered work in accord with this section, you
+++must place, in the relevant source files, a statement of the
+++additional terms that apply to those files, or a notice indicating
+++where to find the applicable terms.
+++
+++ Additional terms, permissive or non-permissive, may be stated in the
+++form of a separately written license, or stated as exceptions;
+++the above requirements apply either way.
+++
+++ 8. Termination.
+++
+++ You may not propagate or modify a covered work except as expressly
+++provided under this License. Any attempt otherwise to propagate or
+++modify it is void, and will automatically terminate your rights under
+++this License (including any patent licenses granted under the third
+++paragraph of section 11).
+++
+++ However, if you cease all violation of this License, then your
+++license from a particular copyright holder is reinstated (a)
+++provisionally, unless and until the copyright holder explicitly and
+++finally terminates your license, and (b) permanently, if the copyright
+++holder fails to notify you of the violation by some reasonable means
+++prior to 60 days after the cessation.
+++
+++ Moreover, your license from a particular copyright holder is
+++reinstated permanently if the copyright holder notifies you of the
+++violation by some reasonable means, this is the first time you have
+++received notice of violation of this License (for any work) from that
+++copyright holder, and you cure the violation prior to 30 days after
+++your receipt of the notice.
+++
+++ Termination of your rights under this section does not terminate the
+++licenses of parties who have received copies or rights from you under
+++this License. If your rights have been terminated and not permanently
+++reinstated, you do not qualify to receive new licenses for the same
+++material under section 10.
+++
+++ 9. Acceptance Not Required for Having Copies.
+++
+++ You are not required to accept this License in order to receive or
+++run a copy of the Program. Ancillary propagation of a covered work
+++occurring solely as a consequence of using peer-to-peer transmission
+++to receive a copy likewise does not require acceptance. However,
+++nothing other than this License grants you permission to propagate or
+++modify any covered work. These actions infringe copyright if you do
+++not accept this License. Therefore, by modifying or propagating a
+++covered work, you indicate your acceptance of this License to do so.
+++
+++ 10. Automatic Licensing of Downstream Recipients.
+++
+++ Each time you convey a covered work, the recipient automatically
+++receives a license from the original licensors, to run, modify and
+++propagate that work, subject to this License. You are not responsible
+++for enforcing compliance by third parties with this License.
+++
+++ An "entity transaction" is a transaction transferring control of an
+++organization, or substantially all assets of one, or subdividing an
+++organization, or merging organizations. If propagation of a covered
+++work results from an entity transaction, each party to that
+++transaction who receives a copy of the work also receives whatever
+++licenses to the work the party's predecessor in interest had or could
+++give under the previous paragraph, plus a right to possession of the
+++Corresponding Source of the work from the predecessor in interest, if
+++the predecessor has it or can get it with reasonable efforts.
+++
+++ You may not impose any further restrictions on the exercise of the
+++rights granted or affirmed under this License. For example, you may
+++not impose a license fee, royalty, or other charge for exercise of
+++rights granted under this License, and you may not initiate litigation
+++(including a cross-claim or counterclaim in a lawsuit) alleging that
+++any patent claim is infringed by making, using, selling, offering for
+++sale, or importing the Program or any portion of it.
+++
+++ 11. Patents.
+++
+++ A "contributor" is a copyright holder who authorizes use under this
+++License of the Program or a work on which the Program is based. The
+++work thus licensed is called the contributor's "contributor version".
+++
+++ A contributor's "essential patent claims" are all patent claims
+++owned or controlled by the contributor, whether already acquired or
+++hereafter acquired, that would be infringed by some manner, permitted
+++by this License, of making, using, or selling its contributor version,
+++but do not include claims that would be infringed only as a
+++consequence of further modification of the contributor version. For
+++purposes of this definition, "control" includes the right to grant
+++patent sublicenses in a manner consistent with the requirements of
+++this License.
+++
+++ Each contributor grants you a non-exclusive, worldwide, royalty-free
+++patent license under the contributor's essential patent claims, to
+++make, use, sell, offer for sale, import and otherwise run, modify and
+++propagate the contents of its contributor version.
+++
+++ In the following three paragraphs, a "patent license" is any express
+++agreement or commitment, however denominated, not to enforce a patent
+++(such as an express permission to practice a patent or covenant not to
+++sue for patent infringement). To "grant" such a patent license to a
+++party means to make such an agreement or commitment not to enforce a
+++patent against the party.
+++
+++ If you convey a covered work, knowingly relying on a patent license,
+++and the Corresponding Source of the work is not available for anyone
+++to copy, free of charge and under the terms of this License, through a
+++publicly available network server or other readily accessible means,
+++then you must either (1) cause the Corresponding Source to be so
+++available, or (2) arrange to deprive yourself of the benefit of the
+++patent license for this particular work, or (3) arrange, in a manner
+++consistent with the requirements of this License, to extend the patent
+++license to downstream recipients. "Knowingly relying" means you have
+++actual knowledge that, but for the patent license, your conveying the
+++covered work in a country, or your recipient's use of the covered work
+++in a country, would infringe one or more identifiable patents in that
+++country that you have reason to believe are valid.
+++
+++ If, pursuant to or in connection with a single transaction or
+++arrangement, you convey, or propagate by procuring conveyance of, a
+++covered work, and grant a patent license to some of the parties
+++receiving the covered work authorizing them to use, propagate, modify
+++or convey a specific copy of the covered work, then the patent license
+++you grant is automatically extended to all recipients of the covered
+++work and works based on it.
+++
+++ A patent license is "discriminatory" if it does not include within
+++the scope of its coverage, prohibits the exercise of, or is
+++conditioned on the non-exercise of one or more of the rights that are
+++specifically granted under this License. You may not convey a covered
+++work if you are a party to an arrangement with a third party that is
+++in the business of distributing software, under which you make payment
+++to the third party based on the extent of your activity of conveying
+++the work, and under which the third party grants, to any of the
+++parties who would receive the covered work from you, a discriminatory
+++patent license (a) in connection with copies of the covered work
+++conveyed by you (or copies made from those copies), or (b) primarily
+++for and in connection with specific products or compilations that
+++contain the covered work, unless you entered into that arrangement,
+++or that patent license was granted, prior to 28 March 2007.
+++
+++ Nothing in this License shall be construed as excluding or limiting
+++any implied license or other defenses to infringement that may
+++otherwise be available to you under applicable patent law.
+++
+++ 12. No Surrender of Others' Freedom.
+++
+++ If conditions are imposed on you (whether by court order, agreement or
+++otherwise) that contradict the conditions of this License, they do not
+++excuse you from the conditions of this License. If you cannot convey a
+++covered work so as to satisfy simultaneously your obligations under this
+++License and any other pertinent obligations, then as a consequence you may
+++not convey it at all. For example, if you agree to terms that obligate you
+++to collect a royalty for further conveying from those to whom you convey
+++the Program, the only way you could satisfy both those terms and this
+++License would be to refrain entirely from conveying the Program.
+++
+++ 13. Use with the GNU Affero General Public License.
+++
+++ Notwithstanding any other provision of this License, you have
+++permission to link or combine any covered work with a work licensed
+++under version 3 of the GNU Affero General Public License into a single
+++combined work, and to convey the resulting work. The terms of this
+++License will continue to apply to the part which is the covered work,
+++but the special requirements of the GNU Affero General Public License,
+++section 13, concerning interaction through a network will apply to the
+++combination as such.
+++
+++ 14. Revised Versions of this License.
+++
+++ The Free Software Foundation may publish revised and/or new versions of
+++the GNU General Public License from time to time. Such new versions will
+++be similar in spirit to the present version, but may differ in detail to
+++address new problems or concerns.
+++
+++ Each version is given a distinguishing version number. If the
+++Program specifies that a certain numbered version of the GNU General
+++Public License "or any later version" applies to it, you have the
+++option of following the terms and conditions either of that numbered
+++version or of any later version published by the Free Software
+++Foundation. If the Program does not specify a version number of the
+++GNU General Public License, you may choose any version ever published
+++by the Free Software Foundation.
+++
+++ If the Program specifies that a proxy can decide which future
+++versions of the GNU General Public License can be used, that proxy's
+++public statement of acceptance of a version permanently authorizes you
+++to choose that version for the Program.
+++
+++ Later license versions may give you additional or different
+++permissions. However, no additional obligations are imposed on any
+++author or copyright holder as a result of your choosing to follow a
+++later version.
+++
+++ 15. Disclaimer of Warranty.
+++
+++ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+++APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+++HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+++OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+++THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+++PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+++IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+++ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+++
+++ 16. Limitation of Liability.
+++
+++ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+++WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+++THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+++GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+++USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+++DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+++PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+++EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+++SUCH DAMAGES.
+++
+++ 17. Interpretation of Sections 15 and 16.
+++
+++ If the disclaimer of warranty and limitation of liability provided
+++above cannot be given local legal effect according to their terms,
+++reviewing courts shall apply local law that most closely approximates
+++an absolute waiver of all civil liability in connection with the
+++Program, unless a warranty or assumption of liability accompanies a
+++copy of the Program in return for a fee.
+++
+++ END OF TERMS AND CONDITIONS
+++
+++ How to Apply These Terms to Your New Programs
+++
+++ If you develop a new program, and you want it to be of the greatest
+++possible use to the public, the best way to achieve this is to make it
+++free software which everyone can redistribute and change under these terms.
+++
+++ To do so, attach the following notices to the program. It is safest
+++to attach them to the start of each source file to most effectively
+++state the exclusion of warranty; and each file should have at least
+++the "copyright" line and a pointer to where the full notice is found.
+++
+++ {one line to give the program's name and a brief idea of what it does.}
+++ Copyright (C) {year} {name of author}
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++Also add information on how to contact you by electronic and paper mail.
+++
+++ If the program does terminal interaction, make it output a short
+++notice like this when it starts in an interactive mode:
+++
+++ {project} Copyright (C) {year} {fullname}
+++ This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+++ This is free software, and you are welcome to redistribute it
+++ under certain conditions; type `show c' for details.
+++
+++The hypothetical commands `show w' and `show c' should show the appropriate
+++parts of the General Public License. Of course, your program's commands
+++might be different; for a GUI interface, you would use an "about box".
+++
+++ You should also get your employer (if you work as a programmer) or school,
+++if any, to sign a "copyright disclaimer" for the program, if necessary.
+++For more information on this, and how to apply and follow the GNU GPL, see
+++<http://www.gnu.org/licenses/>.
+++
+++ The GNU General Public License does not permit incorporating your program
+++into proprietary programs. If your program is a subroutine library, you
+++may consider it more useful to permit linking proprietary applications with
+++the library. If this is what you want to do, use the GNU Lesser General
+++Public License instead of this License. But first, please read
+++<http://www.gnu.org/philosophy/why-not-lgpl.html>.
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/README.rst
++@@ -0,0 +1,199 @@
+++libsimulator
+++============
+++
+++.. image:: https://github.com/arvidn/libsimulator/actions/workflows/ci.yml/badge.svg?branch=master
+++ :target: https://github.com/arvidn/libsimulator/actions/workflows/ci.yml
+++
+++*This is still in initial development, some of this README represents ambitions
+++rather than the current state*
+++
+++libsimulator is a library for running discrete event simulations, implementing
+++the ``boost.asio`` API (or a somewhat faithful emulation of a subset of it,
+++patches are welcome). This makes it practical to be used as a testing tool of
+++real implementations of network software as well as for writing simulators that
+++later turn into live production applications.
+++
+++The simulation has to have a single time-line to be deterministic, meaning it
+++must be single threaded and use a single ``io_service`` as the message queue.
+++These requirements may affect how the program to be tested is written. It may
+++for instance require that an external io_service can be provided rather than one
+++being wrapped in an internal thread.
+++
+++However, ``boost.asio`` programs may generally benefit from being transformed to
+++this form, as the become *composable*, i.e. agnostic to which io_service they
+++run on or how many threads are running it.
+++
+++features
+++--------
+++
+++The currently (partially) supported classes are:
+++
+++* chrono::high_resolution_clock
+++* asio::high_resolution_timer
+++* asio::ip::tcp::acceptor
+++* asio::ip::tcp::endpoint
+++* asio::ip::address (v4 and v6 variants, these just defer to the actual
+++ boost.asio types)
+++* asio::ip::tcp::socket
+++* asio::ip::udp::socket
+++* asio::io_service
+++* asio::ip::udp::resolver
+++* asio::ip::tcp::resolver
+++
+++The ``high_resolution_clock`` in the ``chrono`` namespace implements the timer
+++concept from the chrono library.
+++
+++usage
+++-----
+++
+++The ``io_service`` object is significantly different from the one in boost.asio.
+++This is because one simulation may only have a single message loop and a single
+++ordering of events. This single message loop is provided by the ``simulation``
+++class. Each simulation should have only one such object. An ``io_service``
+++object represents a single node on the network. When creating an io_service, you
+++have to pass in the simulation it belongs to as well as the IP address it should
+++have. It is also possible to pass in multiple addresses to form a multi-homed
+++node. For instance, one with both an IPv4 and IPv6 interface.
+++
+++When creating sockets, binding and connecting them, the io_service object
+++determines what ``INADDR_ANY`` resolves to (the first IP assigned to that node).
+++
+++The only aspects of the io_service interface that's preserved are ``post()``,
+++``dispatch()`` and constructing timers and sockets. In short, the ``run()`` and
+++``poll()`` family of functions do not exist. Every io_service object is assumed
+++to be run, and all of their events are handled by the simulation object.
+++
+++None of the synchronous APIs are supported, because that would require
+++integration with OS threads and scheduler.
+++
+++example
+++-------
+++
+++Here's a simple example illustrating the asio timer::
+++
+++ #include "simulator/simulator.hpp"
+++ #include <functional>
+++ #include <boost/system.hpp>
+++
+++ void print_time(sim::asio::high_resolution_timer& timer
+++ , boost::system::error_code const& ec)
+++ {
+++ using namespace sim::chrono;
+++ static int counter = 0;
+++
+++ printf("[%d] timer fired at: %d milliseconds. error: %s\n"
+++ , counter
+++ , int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count())
+++ , ec.message().c_str());
+++
+++ ++counter;
+++ if (counter < 5)
+++ {
+++ timer.expires_from_now(seconds(counter));
+++ timer.async_wait(std::bind(&print_time, std::ref(timer), _1));
+++ }
+++ }
+++
+++ int main()
+++ {
+++ using namespace sim::chrono;
+++
+++ default_config cfg;
+++ simulation sim(cfg);
+++ io_service ios(sim, ip::address_v4::from_string("1.2.3.4"));
+++ sim::asio::high_resolution_timer timer(ios);
+++
+++ timer.expires_from_now(seconds(1));
+++ timer.async_wait(std::bind(&print_time, std::ref(timer), _1));
+++
+++ boost::system::error_code ec;
+++ sim.run(ec);
+++
+++ printf("sim::run() returned: %s at: %d\n"
+++ , ec.message().c_str()
+++ , int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count()));
+++ }
+++
+++The output from this program is::
+++
+++ [0] timer fired at: 1000 milliseconds. error: Undefined error: 0
+++ [1] timer fired at: 2000 milliseconds. error: Undefined error: 0
+++ [2] timer fired at: 4000 milliseconds. error: Undefined error: 0
+++ [3] timer fired at: 7000 milliseconds. error: Undefined error: 0
+++ [4] timer fired at: 11000 milliseconds. error: Undefined error: 0
+++ io_service::run() returned: Undefined error: 0 at: 11000
+++
+++And obviously it doesn't take 11 wall-clock seconds to run (it returns
+++instantly).
+++
+++configuration
+++-------------
+++
+++The simulated network can be configured with per-node pair bandwidth, round-trip
+++latency and queue sizes. This is controlled via a callback interface that
+++libsimulator will ask for these properties when nodes get connected.
+++
+++The resolution of hostnames is also configurable by providing a callback on the
+++configuration object along with the latency of individual lookups.
+++
+++To configure the network for the simulation, pass in a reference to an object
+++implementing the ``sim::configuration`` interface::
+++
+++ struct configuration
+++ {
+++ // build the network
+++ virtual void build(simulation& sim) = 0;
+++
+++ // return the hops on the network packets from src to dst need to traverse
+++ virtual route channel_route(asio::ip::address src
+++ , asio::ip::address dst) = 0;
+++
+++ // return the hops an incoming packet to ep need to traverse before
+++ // reaching the socket (for instance a NAT)
+++ virtual route incoming_route(asio::ip::address ip) = 0;
+++
+++ // return the hops an outgoing packet from ep need to traverse before
+++ // reaching the network (for instance a DSL modem)
+++ virtual route outgoing_route(asio::ip::address ip) = 0;
+++
+++ // return the path MTU between the two IP addresses
+++ // For TCP sockets, this will be called once when the connection is
+++ // established. For UDP sockets it's called for every burst of packets
+++ // that are sent
+++ virtual int path_mtu(asio::ip::address ip1, asio::ip::address ip2) = 0;
+++
+++ // called for every hostname lookup made by the client. ``reqyestor`` is
+++ // the node performing the lookup, ``hostname`` is the name being looked
+++ // up. Resolve the name into addresses and fill in ``result`` or set
+++ // ``ec`` if the hostname is not found or some other error occurs. The
+++ // return value is the latency of the lookup. The client's callback won't
+++ // be called until after waiting this long.
+++ virtual chrono::high_resolution_clock::duration hostname_lookup(
+++ asio::ip::address const& requestor
+++ , std::string hostname
+++ , std::vector<asio::ip::address>& result
+++ , boost::system::error_code& ec) = 0;
+++ };
+++
+++``build()`` is called right after the simulation is constructed. It gives the
+++configuration object an opportunity to construct the core queues, since they
+++need access to the simulator.
+++
+++``channel_route()`` is expected to return a *route* of network hops from the
+++source IP to the destination IP. A route is a series of ``sink`` objects. The
+++typical sink is a ``sim::queue``, which is a network node with a specific rate
+++limit, propagation delay and queue size.
+++
+++*TODO: finish document configuration interface*
+++
+++history
+++-------
+++
+++libsimulator grew out of libtorrent's unit tests, as a tool to make them reliable
+++and deterministic (i.e. not depend on external systems like sockets and timers)
+++and also easier to debug. The subset of the asio API initially supported by this
+++library is the subset used by libtorrent. Patches are welcome to improve
+++fidelity and support.
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/chrono.hpp
++@@ -0,0 +1,87 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef CHRONO_HPP_INCLUDED
+++#define CHRONO_HPP_INCLUDED
+++
+++#include <boost/config.hpp>
+++#include "simulator/config.hpp"
+++
+++#if defined BOOST_ASIO_HAS_STD_CHRONO
+++#include <chrono>
+++#else
+++#include "simulator/push_warnings.hpp"
+++
+++#include <boost/chrono/duration.hpp>
+++#include <boost/chrono/time_point.hpp>
+++#include <boost/ratio.hpp>
+++
+++#include "simulator/pop_warnings.hpp"
+++#endif
+++
+++namespace sim { namespace chrono
+++{
+++#if defined BOOST_ASIO_HAS_STD_CHRONO
+++ using std::chrono::seconds;
+++ using std::chrono::milliseconds;
+++ using std::chrono::microseconds;
+++ using std::chrono::nanoseconds;
+++ using std::chrono::minutes;
+++ using std::chrono::hours;
+++ using std::chrono::duration_cast;
+++ using std::chrono::time_point;
+++ using std::chrono::duration;
+++#else
+++ using boost::chrono::seconds;
+++ using boost::chrono::milliseconds;
+++ using boost::chrono::microseconds;
+++ using boost::chrono::nanoseconds;
+++ using boost::chrono::minutes;
+++ using boost::chrono::hours;
+++ using boost::chrono::duration_cast;
+++ using boost::chrono::time_point;
+++ using boost::chrono::duration;
+++#endif
+++
+++ // std.chrono / boost.chrono compatible high_resolution_clock using a simulated time
+++ struct SIMULATOR_DECL high_resolution_clock
+++ {
+++ using rep = std::int64_t;
+++#if defined BOOST_ASIO_HAS_STD_CHRONO
+++ using period = std::nano;
+++ using time_point = std::chrono::time_point<high_resolution_clock, nanoseconds>;
+++ using duration = std::chrono::duration<boost::int64_t, std::nano>;
+++#else
+++ using period = boost::nano;
+++ using time_point = time_point<high_resolution_clock, nanoseconds>;
+++ using duration = duration<boost::int64_t, boost::nano>;
+++#endif
+++ static const bool is_steady = true;
+++ static time_point now();
+++
+++ // private interface
+++ static void fast_forward(high_resolution_clock::duration d);
+++ };
+++
+++ SIMULATOR_DECL void reset_clock();
+++
+++} // chrono
+++} // sim
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/config.hpp
++@@ -0,0 +1,51 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef CONFIG_HPP_INCLUDED
+++#define CONFIG_HPP_INCLUDED
+++
+++#include "simulator/push_warnings.hpp"
+++#include <boost/config.hpp>
+++#include "simulator/pop_warnings.hpp"
+++
+++#ifdef SIMULATOR_BUILDING_SHARED
+++#define SIMULATOR_DECL BOOST_SYMBOL_EXPORT
+++#elif defined SIMULATOR_LINKING_SHARED
+++#define SIMULATOR_DECL BOOST_SYMBOL_IMPORT
+++#else
+++#define SIMULATOR_DECL
+++#endif
+++
+++#if defined __clang__ || defined __GNUC__
+++#define LIBSIMULATOR_NO_RETURN __attribute((noreturn))
+++#elif _MSC_VER
+++#define LIBSIMULATOR_NO_RETURN __declspec(noreturn)
+++#else
+++#define LIBSIMULATOR_NO_RETURN
+++#endif
+++
+++#ifdef _MSC_VER
+++#pragma warning(push)
+++// warning C4251: X: class Y needs to have dll-interface to be used by clients of struct
+++#pragma warning( disable : 4251)
+++// warning C4661: X: no suitable definition provided for explicit template instantiation request
+++#pragma warning( disable : 4661)
+++#endif
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/function.hpp
++@@ -0,0 +1,220 @@
+++/*
+++
+++Copyright (c) 2017, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef SIMULATOR_FUNCTION_HPP_INCLUDED
+++#define SIMULATOR_FUNCTION_HPP_INCLUDED
+++
+++#include <utility>
+++#include <memory> // for allocator_traits
+++
+++#include "simulator/mallocator.hpp"
+++
+++namespace sim {
+++namespace aux {
+++
+++ template <typename T, typename U>
+++ T exchange_(T& var, U&& new_val)
+++ {
+++ T temp = std::move(var);
+++ var = std::forward<U>(new_val);
+++ return temp;
+++ }
+++
+++ template <typename T, typename Fun>
+++ T* allocate_handler(Fun h)
+++ {
+++ using alloc = typename boost::asio::associated_allocator<typename std::remove_reference<Fun>::type>::type;
+++ using our_alloc = typename std::allocator_traits<alloc>::template rebind_alloc<T>;
+++ our_alloc al(boost::asio::get_associated_allocator(h));
+++ void* ptr = al.allocate(1);
+++ if (ptr == nullptr) throw std::bad_alloc();
+++ try {
+++ return new (ptr) T(std::move(h));
+++ }
+++ catch (...) {
+++ al.deallocate(reinterpret_cast<T*>(ptr), 1);
+++ throw;
+++ }
+++ }
+++
+++ // this is a std::function-like class that supports move-only function
+++ // objects
+++ template <typename R, typename... A>
+++ struct callable
+++ {
+++ using call_fun_t = R (*)(void*, A&&...);
+++ using deallocate_fun_t = void (*)(void*);
+++ call_fun_t call_fun;
+++ deallocate_fun_t deallocate_fun;
+++ };
+++
+++ template <typename Handler, typename R, typename... A>
+++ R call_impl(void* mem, A&&... a);
+++
+++ template <typename Handler, typename R, typename... A>
+++ void dealloc_impl(void* mem);
+++
+++ template <typename Handler, typename R, typename... A>
+++ struct function_impl : callable<R, A...>
+++ {
+++ function_impl(Handler h)
+++ : handler(std::move(h))
+++ {
+++ this->call_fun = call_impl<Handler, R, A&&...>;
+++ this->deallocate_fun = dealloc_impl<Handler, R, A&&...>;
+++ }
+++ Handler handler;
+++ };
+++
+++ template <typename Handler, typename R, typename... A>
+++ R call_impl(void* mem, A&&... a)
+++ {
+++ auto* obj = static_cast<function_impl<Handler, R, A...>*>(mem);
+++ Handler handler = std::move(obj->handler);
+++
+++ obj->~function_impl();
+++ using alloc = typename boost::asio::associated_allocator<Handler>::type;
+++ using our_alloc = typename std::allocator_traits<alloc>::
+++ template rebind_alloc<typename std::remove_reference<decltype(*obj)>::type>;
+++ our_alloc al(boost::asio::get_associated_allocator(handler));
+++ al.deallocate(obj, 1);
+++
+++ return handler(std::forward<A>(a)...);
+++ }
+++
+++ template <typename Handler, typename R, typename... A>
+++ void dealloc_impl(void* mem)
+++ {
+++ auto* obj = static_cast<function_impl<Handler, R, A...>*>(mem);
+++ Handler h = std::move(obj->handler);
+++
+++ obj->~function_impl();
+++ using alloc = typename boost::asio::associated_allocator<Handler>::type;
+++ using our_alloc = typename std::allocator_traits<alloc>::
+++ template rebind_alloc<typename std::remove_reference<decltype(*obj)>::type>;
+++ our_alloc al(boost::asio::get_associated_allocator(h));
+++ al.deallocate(obj, 1);
+++ }
+++
+++ template <typename Fun>
+++ struct function;
+++
+++ template <typename R, typename... A>
+++ struct function<R(A...)>
+++ {
+++ using result_type = R;
+++
+++ using allocator_type = aux::mallocator<R(A...)>;
+++ allocator_type get_allocator() const { return allocator_type{}; }
+++
+++ template <typename C>
+++ function(C c)
+++ : m_callable(allocate_handler<function_impl<C, R, A...>>(std::move(c)))
+++ {}
+++ function(function&& other) noexcept
+++ : m_callable(exchange_(other.m_callable, nullptr))
+++ {}
+++ function& operator=(function&& other) noexcept
+++ {
+++ if (&other == this) return *this;
+++ clear();
+++ m_callable = exchange_(other.m_callable, nullptr);
+++ return *this;
+++ }
+++
+++ ~function() { clear(); }
+++
+++ // boost.asio requires handlers to be copy-constructible, but it will move
+++ // them, if they're movable. So we trick asio into accepting this handler.
+++ // If it attempts to copy, it will cause a link error
+++ function(function const&) { assert(false && "functions should not be copied"); }
+++ function& operator=(function const&) = delete;
+++
+++ function() = default;
+++ explicit operator bool() const { return m_callable != nullptr; }
+++ function& operator=(std::nullptr_t) { clear(); return *this; }
+++ void clear()
+++ {
+++ if (m_callable == nullptr) return;
+++ auto fun = m_callable->deallocate_fun;
+++ fun(m_callable);
+++ m_callable = nullptr;
+++ }
+++ template <typename... Args>
+++ R operator()(Args&&... a)
+++ {
+++ assert(m_callable);
+++ auto fun = m_callable->call_fun;
+++ return fun(exchange_(m_callable, nullptr), std::forward<A>(a)...);
+++ }
+++ private:
+++ callable<R, A...>* m_callable = nullptr;
+++ };
+++
+++ // index sequence, to unpack tuple
+++ template<std::size_t...> struct seq {};
+++ template<std::size_t N, std::size_t... S> struct gens : gens<N-1, N-1, S...> {};
+++ template<std::size_t... S> struct gens<0, S...> { using type = seq<S...>; };
+++
+++ // a binder for move-only types, and movable arguments. It's not a general
+++ // binder as it doesn't support partial application, it just binds all
+++ // arguments and ignores any arguments passed to the call
+++ template <typename Callable, typename R, typename... A>
+++ struct move_binder
+++ {
+++ move_binder(Callable c, A&&... a)
+++ : m_args(std::move(a)...)
+++ , m_callable(std::move(c))
+++ {}
+++
+++ move_binder(move_binder const&) = delete;
+++ move_binder& operator=(move_binder const&) = delete;
+++
+++ move_binder(move_binder&&) = default;
+++ move_binder& operator=(move_binder&&) = default;
+++
+++ // ignore any arguments passed in. This is used to ignore an error_code
+++ // argument for instance
+++ template <typename... Args>
+++ R operator()(Args...)
+++ {
+++ return call(typename gens<sizeof...(A)>::type());
+++ }
+++
+++ private:
+++
+++ template<std::size_t... I>
+++ R call(seq<I...>)
+++ {
+++ return m_callable(std::move(std::get<I>(m_args))...);
+++ }
+++ std::tuple<A...> m_args;
+++ Callable m_callable;
+++ };
+++
+++ template <typename R, typename C, typename... A>
+++ move_binder<C, R, A...> move_bind(C c, A&&... a)
+++ {
+++ return move_binder<C, R, A...>(std::move(c), std::forward<A>(a)...);
+++ }
+++
+++}
+++}
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/handler_allocator.hpp
++@@ -0,0 +1,81 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef HANDLER_ALLOCATOR_HPP_INCLUDED
+++#define HANDLER_ALLOCATOR_HPP_INCLUDED
+++
+++namespace sim
+++{
+++namespace aux
+++{
+++
+++template <typename T>
+++struct malloc_allocator
+++{
+++ using value_type = T;
+++ using size_type = std::size_t;
+++
+++ friend bool operator==(malloc_allocator, malloc_allocator) { return true; }
+++ friend bool operator!=(malloc_allocator, malloc_allocator) { return false; }
+++
+++ template <class U>
+++ struct rebind { using other = malloc_allocator<U>; };
+++
+++ malloc_allocator() = default;
+++ template <typename U>
+++ malloc_allocator(malloc_allocator<U> const&) {}
+++
+++ T* allocate(std::size_t size) { return static_cast<T*>(std::malloc(size * sizeof(T))); }
+++ void deallocate(T* pointer, std::size_t) { std::free(pointer); }
+++ using is_always_equal = std::true_type;
+++};
+++
+++// this is a handler wrapper that customizes the asio handler allocator to use
+++// malloc instead of new. The purpose is to distinguish allocations that are
+++// internal to the simulator and allocations part of the program under test.
+++template <typename Handler>
+++struct malloc_wrapper
+++{
+++ malloc_wrapper(Handler h) : m_handler(std::move(h)) {}
+++
+++ template <typename... Args>
+++ void operator()(Args&&... a)
+++ {
+++ m_handler(std::forward<Args>(a)...);
+++ }
+++
+++ using allocator_type = malloc_allocator<malloc_wrapper<Handler>>;
+++
+++ allocator_type get_allocator() const noexcept
+++ { return allocator_type{}; }
+++
+++private:
+++ Handler m_handler;
+++};
+++
+++template <typename T>
+++malloc_wrapper<T> make_malloc(T h)
+++{
+++ return malloc_wrapper<T>(std::move(h));
+++}
+++
+++}
+++}
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/http_proxy.hpp
++@@ -0,0 +1,103 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef HTTP_PROXY_HPP_INCLUDED
+++#define HTTP_PROXY_HPP_INCLUDED
+++
+++#include "simulator/simulator.hpp"
+++
+++#ifdef _MSC_VER
+++#pragma warning(push)
+++// warning C4251: X: class Y needs to have dll-interface to be used by clients of struct
+++#pragma warning( disable : 4251)
+++#endif
+++
+++namespace sim
+++{
+++ struct http_request;
+++
+++// This is a very simple http proxy that only supports a single
+++// concurrent connection
+++struct SIMULATOR_DECL http_proxy
+++{
+++ http_proxy(asio::io_context& ios, unsigned short listen_port);
+++
+++ void stop();
+++
+++private:
+++
+++ void on_accept(boost::system::error_code const& ec);
+++ void on_read_request(boost::system::error_code const& ec, size_t bytes_transferred);
+++
+++ void forward_request(http_request const& req);
+++ void open_forward_connection(const asio::ip::tcp::endpoint& target);
+++ void on_connected(boost::system::error_code const& ec);
+++
+++ void on_domain_lookup(boost::system::error_code const& ec
+++ , const asio::ip::tcp::resolver::results_type ips);
+++
+++ void write_server_send_buffer();
+++ void on_server_write(boost::system::error_code const& ec, size_t bytes_transferred);
+++
+++ void on_server_receive(boost::system::error_code const& ec
+++ , std::size_t bytes_transferred);
+++ void on_server_forward(boost::system::error_code const& ec, size_t bytes_transferred);
+++
+++ void error(int code, char const* message);
+++ void close_connection();
+++
+++ asio::ip::tcp::resolver m_resolver;
+++ asio::ip::tcp::acceptor m_listen_socket;
+++
+++ // this is the client connection, i.e. the client connecting to us, sending
+++ // HTTP requests that we forward
+++ asio::ip::tcp::socket m_client_connection;
+++ // client endpoint
+++ asio::ip::tcp::endpoint m_ep;
+++
+++ // this is the connection to the server the client's requests are forwarded
+++ // to
+++ asio::ip::tcp::socket m_server_connection;
+++ // true while there is an outstanding write operation to the server
+++ bool m_writing_to_server;
+++
+++ // receive buffer for requests from the client. i.e. client -> proxy (us) -> server
+++ char m_client_in_buffer[65536];
+++ // buffer size
+++ int m_num_client_in_bytes;
+++
+++ char m_server_out_buffer[65536];
+++ int m_num_server_out_bytes;
+++
+++ // receive buffer for incoming responses, i.e. server -> proxy (us) -> client
+++ char m_in_buffer[65536];
+++ // buffer size
+++ int m_num_in_bytes;
+++
+++ // set to true when shutting down
+++ bool m_close;
+++};
+++
+++}
+++
+++#ifdef _MSC_VER
+++#pragma warning(pop)
+++#endif
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/http_server.hpp
++@@ -0,0 +1,134 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef HTTP_SERVER_HPP_INCLUDED
+++#define HTTP_SERVER_HPP_INCLUDED
+++
+++#include "simulator/simulator.hpp"
+++#include <string>
+++
+++#ifdef _MSC_VER
+++#pragma warning(push)
+++// warning C4251: X: class Y needs to have dll-interface to be used by clients of struct
+++#pragma warning( disable : 4251)
+++#endif
+++
+++namespace sim
+++{
+++ std::string SIMULATOR_DECL trim(std::string s);
+++
+++ std::string SIMULATOR_DECL lower_case(std::string s);
+++
+++ std::string SIMULATOR_DECL normalize(const std::string& s);
+++
+++ // returns the index to the last byte of the request, or -1 if the buffer
+++ // does not contain a full http request
+++ int SIMULATOR_DECL find_request_len(char const* buf, int len);
+++
+++ struct http_request
+++ {
+++ std::string method;
+++ std::string req;
+++ std::string path;
+++ std::map<std::string, std::string> headers;
+++ };
+++
+++ http_request parse_request(char const* start, int len);
+++
+++ // builds an HTTP response buffer
+++ std::string SIMULATOR_DECL send_response(int code, char const* status_message
+++ , int len = 0, char const** extra_header = NULL);
+++
+++// This is a very simple http server that only supports a single concurrent
+++// connection
+++struct SIMULATOR_DECL http_server
+++{
+++ enum flags_t
+++ {
+++ keep_alive = 1,
+++ // behave like an HTTP/1.0 server: respond with an HTTP/1.0 status line
+++ // and close the connection after each response. HTTP/1.0 has no
+++ // persistent connections, and the Connection header is an HTTP/1.1
+++ // mechanism, so no "Connection: close" is sent -- the client must detect
+++ // the close from the protocol version (and the socket closing).
+++ http_1_0 = 2
+++ };
+++
+++ http_server(asio::io_context& ios, unsigned short listen_port
+++ , int flags = http_server::keep_alive);
+++
+++ void stop();
+++
+++ using handler_t = std::function<std::string (std::string, std::string
+++ , std::map<std::string, std::string>&)>;
+++ using generator_t = std::function<std::string (std::int64_t, std::int64_t)>;
+++
+++ void register_handler(std::string const& path, handler_t h);
+++ void register_content(std::string const& path
+++ , std::int64_t const size, generator_t gen);
+++ void register_redirect(std::string const& path, std::string const& target);
+++ void register_stall_handler(std::string const& path);
+++
+++ // the number of TCP connections that have been accepted so far
+++ int accepted_connections() const { return m_accepted_connections; }
+++
+++private:
+++
+++ void on_accept(boost::system::error_code const& ec);
+++ void read();
+++ void on_read(boost::system::error_code const& ec, size_t bytes_transferred);
+++ void on_write(boost::system::error_code const& ec, size_t bytes_transferred
+++ , bool close);
+++ void close_connection();
+++
+++ asio::io_context& m_ios;
+++
+++ asio::ip::tcp::acceptor m_listen_socket;
+++
+++ asio::ip::tcp::socket m_connection;
+++ asio::ip::tcp::endpoint m_ep;
+++
+++ std::unordered_map<std::string, handler_t> m_handlers;
+++ std::set<std::string> m_stall_handlers;
+++
+++ // read buffer, we receive bytes into this buffer for the connection
+++ std::string m_recv_buffer;
+++
+++ // the number of bytes of m_recv_buffer that we've actually read data into.
+++ // The remaining is uninitialized, possibly being read into in an async call
+++ int m_bytes_used;
+++
+++ std::string m_send_buffer;
+++
+++ // set to true when shutting down
+++ bool m_close;
+++
+++ int m_flags;
+++
+++ // counts the number of accepted TCP connections
+++ int m_accepted_connections = 0;
+++};
+++
+++}
+++
+++#ifdef _MSC_VER
+++#pragma warning(pop)
+++#endif
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/mallocator.hpp
++@@ -0,0 +1,69 @@
+++/*
+++
+++Copyright (c) 2017, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef SIMULATOR_MALLOCATOR_HPP_INCLUDED
+++#define SIMULATOR_MALLOCATOR_HPP_INCLUDED
+++
+++namespace sim
+++{
+++namespace aux
+++{
+++ struct channel;
+++ struct packet;
+++ struct pcap;
+++
+++ template <typename T>
+++ struct mallocator
+++ {
+++ template <typename U>
+++ friend struct mallocator;
+++
+++ using value_type = T;
+++ using pointer = T*;
+++ using const_pointer = T const*;
+++ using reference = T&;
+++ using const_reference = T const&;
+++ using size_type = std::size_t;
+++ using difference_type = std::ptrdiff_t;
+++
+++ template <class U>
+++ struct rebind {
+++ using other = mallocator<U>;
+++ };
+++
+++ mallocator() = default;
+++ template <typename U>
+++ mallocator(mallocator<U> const&) {}
+++
+++ T* allocate(std::size_t size)
+++ { return reinterpret_cast<T*>(std::malloc(size * sizeof(T))); }
+++
+++ void deallocate(T* ptr) { std::free(ptr); }
+++ void deallocate(T* ptr, std::size_t) { std::free(ptr); }
+++
+++ void destroy(pointer p) { p->~T(); }
+++ void construct(pointer p, T&& value) { new (p) T(std::move(value)); }
+++
+++ bool operator==(mallocator const&) const { return true; }
+++ bool operator!=(mallocator const&) const { return false; }
+++ };
+++} // aux
+++} // sim
+++
+++#endif // SIMULATOR_MALLOCATOR_HPP_INCLUDED
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/nat.hpp
++@@ -0,0 +1,51 @@
+++/*
+++
+++Copyright (c) 2018, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef NAT_HPP_INCLUDED
+++#define NAT_HPP_INCLUDED
+++
+++#include "simulator/sink.hpp"
+++#include "simulator/simulator.hpp"
+++#include <string>
+++
+++namespace sim {
+++
+++namespace aux {
+++ struct packet;
+++}
+++
+++ struct SIMULATOR_DECL nat : sink
+++ {
+++ nat(asio::ip::address external_addr);
+++ ~nat() = default;
+++
+++ void incoming_packet(aux::packet p) override;
+++
+++ // used for visualization
+++ std::string label() const override;
+++
+++ private:
+++
+++ asio::ip::address m_external_addr;
+++ };
+++
+++} // sim
+++
+++#endif
+++
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/noexcept_movable.hpp
++@@ -0,0 +1,56 @@
+++/*
+++
+++Copyright (c) 2017, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef NOEXCEPT_MOVABLE_HPP_INCLUDED
+++#define NOEXCEPT_MOVABLE_HPP_INCLUDED
+++
+++namespace sim {
+++namespace aux {
+++
+++ template <typename T>
+++ struct noexcept_movable : T
+++ {
+++ noexcept_movable() noexcept {}
+++ noexcept_movable(noexcept_movable<T>&& rhs) noexcept
+++ : T(std::forward<T>(rhs))
+++ {}
+++ noexcept_movable(noexcept_movable<T> const& rhs)
+++ : T(static_cast<T const&>(rhs))
+++ {}
+++ noexcept_movable(T&& rhs) noexcept : T(std::forward<T>(rhs)) {} // NOLINT
+++ noexcept_movable(T const& rhs) : T(rhs) {} // NOLINT
+++ noexcept_movable& operator=(noexcept_movable&& rhs) noexcept
+++ {
+++ this->T::operator=(std::forward<T>(rhs));
+++ return *this;
+++ }
+++ noexcept_movable& operator=(noexcept_movable const& rhs)
+++ {
+++ this->T::operator=(rhs);
+++ return *this;
+++ }
+++
+++ using T::T;
+++ using T::operator=;
+++ };
+++
+++}
+++}
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/packet.hpp
++@@ -0,0 +1,94 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef PACKET_HPP_INCLUDED
+++#define PACKET_HPP_INCLUDED
+++
+++#include "simulator/config.hpp"
+++#include "simulator/simulator.hpp" // for route, endpoint
+++
+++namespace sim { namespace aux {
+++
+++ struct channel;
+++
+++ struct packet
+++ {
+++ packet() = default;
+++
+++ // this is move-only
+++ packet(packet const&) = delete;
+++ packet& operator=(packet const&) = delete;
+++ packet(packet&&) = default;
+++ packet& operator=(packet&&) = default;
+++
+++ // to keep things simple, don't drop ACKs or errors
+++ bool ok_to_drop() const
+++ {
+++ return type != type_t::syn_ack
+++ && type != type_t::ack
+++ && type != type_t::error;
+++ }
+++
+++ enum class type_t
+++ {
+++ uninitialized, // invalid type (used for debugging)
+++ syn, // TCP connect
+++ syn_ack, // TCP connection accepted
+++ ack, // the seq_nr is interpreted as "we received this"
+++ error, // the error_code (ec) is set
+++ payload // the buffer is filled
+++ };
+++
+++ type_t type = type_t::uninitialized;
+++
+++ boost::system::error_code ec;
+++
+++ // actual payload
+++ std::vector<boost::uint8_t> buffer;
+++
+++ // used for UDP packets
+++ asio::ip::udp::endpoint from;
+++
+++ // the number of bytes of overhead for this packet. The total packet
+++ // size is the number of bytes in the buffer + this number
+++ int overhead = 20;
+++
+++ // each hop in the route will pop itself off and forward the packet to
+++ // the next hop
+++ route hops;
+++
+++ // for SYN packets, this is set to the channel we're trying to
+++ // establish
+++ std::shared_ptr<aux::channel> channel;
+++
+++ // sequence number of this packet (used for debugging)
+++ std::uint64_t seq_nr = 0;
+++
+++ // the number of (payload) bytes sent over this channel so far. This is
+++ // meant to map to the TCP sequence number
+++ std::uint32_t byte_counter = 0;
+++
+++ // this function must be called with this packet in case the packet is
+++ // dropped.
+++ aux::function<void(aux::packet)> drop_fun;
+++ };
+++
+++}} // sim
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/pcap.hpp
++@@ -0,0 +1,42 @@
+++/*
+++
+++Copyright (c) 2017, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef PCAP_HPP_INCLUDED
+++#define PCAP_HPP_INCLUDED
+++
+++#include <fstream>
+++#include "simulator/simulator.hpp" // for endpoint
+++
+++namespace sim { namespace aux
+++{
+++ struct packet;
+++
+++ struct pcap
+++ {
+++ pcap(char const* filename);
+++ void log_tcp(packet const& p, asio::ip::tcp::endpoint src
+++ , asio::ip::tcp::endpoint dst);
+++ void log_udp(packet const& p, asio::ip::udp::endpoint src
+++ , asio::ip::udp::endpoint dst);
+++ private:
+++ std::fstream m_file;
+++ };
+++}}
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/pop_warnings.hpp
++@@ -0,0 +1,44 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++Redistribution and use in source and binary forms, with or without
+++modification, are permitted provided that the following conditions
+++are met:
+++
+++ * Redistributions of source code must retain the above copyright
+++ notice, this list of conditions and the following disclaimer.
+++ * Redistributions in binary form must reproduce the above copyright
+++ notice, this list of conditions and the following disclaimer in
+++ the documentation and/or other materials provided with the distribution.
+++ * Neither the name of the author nor the names of its
+++ contributors may be used to endorse or promote products derived
+++ from this software without specific prior written permission.
+++
+++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+++POSSIBILITY OF SUCH DAMAGE.
+++
+++*/
+++
+++#ifdef _MSC_VER
+++#pragma warning(pop)
+++#endif
+++
+++#ifdef __clang__
+++#pragma clang diagnostic pop
+++#endif
+++
+++#ifdef __GNUC__
+++#pragma GCC diagnostic pop
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/push_warnings.hpp
++@@ -0,0 +1,89 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++Redistribution and use in source and binary forms, with or without
+++modification, are permitted provided that the following conditions
+++are met:
+++
+++ * Redistributions of source code must retain the above copyright
+++ notice, this list of conditions and the following disclaimer.
+++ * Redistributions in binary form must reproduce the above copyright
+++ notice, this list of conditions and the following disclaimer in
+++ the documentation and/or other materials provided with the distribution.
+++ * Neither the name of the author nor the names of its
+++ contributors may be used to endorse or promote products derived
+++ from this software without specific prior written permission.
+++
+++THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+++AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+++IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+++ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+++LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+++CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+++SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+++INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+++CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+++ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+++POSSIBILITY OF SUCH DAMAGE.
+++
+++*/
+++
+++#ifdef __GNUC__
+++#pragma GCC diagnostic push
+++#pragma GCC diagnostic ignored "-Wall"
+++#pragma GCC diagnostic ignored "-Wsign-conversion"
+++#pragma GCC diagnostic ignored "-Wconversion"
+++#pragma GCC diagnostic ignored "-Wswitch-enum"
+++#pragma GCC diagnostic ignored "-Wold-style-cast"
+++#pragma GCC diagnostic ignored "-Wundef"
+++#pragma GCC diagnostic ignored "-Wmissing-noreturn"
+++#pragma GCC diagnostic ignored "-Wdeprecated"
+++#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+++#pragma GCC diagnostic ignored "-Wshadow"
+++#pragma GCC diagnostic ignored "-Wunused-variable"
+++#pragma GCC diagnostic ignored "-Wpedantic"
+++#if __GNUC__ >= 6
+++#pragma GCC diagnostic ignored "-Wshift-overflow"
+++#pragma GCC diagnostic ignored "-Wshift-count-overflow"
+++#pragma GCC diagnostic ignored "-Wshift-count-negative"
+++#endif
+++#endif
+++
+++#ifdef __clang__
+++#pragma clang diagnostic push
+++#pragma clang diagnostic ignored "-Wall"
+++#pragma clang diagnostic ignored "-Weverything"
+++#pragma clang diagnostic ignored "-Wsign-conversion"
+++#pragma clang diagnostic ignored "-Wconversion"
+++#pragma clang diagnostic ignored "-Wswitch-enum"
+++#pragma clang diagnostic ignored "-Wcovered-switch-default"
+++#pragma clang diagnostic ignored "-Wold-style-cast"
+++#pragma clang diagnostic ignored "-Wundef"
+++#pragma clang diagnostic ignored "-Wweak-vtables"
+++#pragma clang diagnostic ignored "-Wmissing-noreturn"
+++#pragma clang diagnostic ignored "-Wdeprecated"
+++#pragma clang diagnostic ignored "-Wdeprecated-declarations"
+++#pragma clang diagnostic ignored "-Wcast-align"
+++#pragma clang diagnostic ignored "-Wweak-vtable"
+++#pragma clang diagnostic ignored "-Wundef"
+++#pragma clang diagnostic ignored "-Wshadow"
+++#pragma clang diagnostic ignored "-Wimplicit-fallthrough"
+++#pragma clang diagnostic ignored "-Wc++11-long-long"
+++#pragma clang diagnostic ignored "-Wc++11-extensions"
+++#pragma clang diagnostic ignored "-Wextra-semi"
+++#pragma clang diagnostic ignored "-Wunused-parameter"
+++#pragma clang diagnostic ignored "-Wreserved-id-macro"
+++#pragma clang diagnostic ignored "-Wunused-local-typedef"
+++#pragma clang diagnostic ignored "-Wgnu-folding-constant"
+++#pragma clang diagnostic ignored "-Wdouble-promotion"
+++#pragma clang diagnostic ignored "-Wfloat-equal"
+++#endif
+++
+++#ifdef _MSC_VER
+++#pragma warning(push, 1)
+++// warning C4005: macro redefinition
+++#pragma warning( disable : 4005 )
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/queue.hpp
++@@ -0,0 +1,100 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef QUEUE_HPP_INCLUDED
+++#define QUEUE_HPP_INCLUDED
+++
+++#include "simulator/simulator.hpp"
+++#include "simulator/packet.hpp"
+++#include "simulator/mallocator.hpp"
+++
+++#ifdef _MSC_VER
+++#pragma warning(push)
+++// warning C4251: X: class Y needs to have dll-interface to be used by clients of struct
+++#pragma warning( disable : 4251)
+++#endif
+++
+++namespace sim {
+++
+++ struct timed_packet
+++ {
+++ timed_packet(chrono::high_resolution_clock::time_point t, aux::packet p)
+++ : ts(t), pkt(std::move(p))
+++ {}
+++ timed_packet(timed_packet&&) = default;
+++ timed_packet& operator=(timed_packet&&) = default;
+++ timed_packet(timed_packet const&) = delete;
+++ timed_packet& operator=(timed_packet const&) = delete;
+++ chrono::high_resolution_clock::time_point ts;
+++ aux::packet pkt;
+++ };
+++
+++ // this is a queue. It can be configured to contrain
+++ struct SIMULATOR_DECL queue : sink
+++ {
+++ queue(asio::io_context& ios, int bandwidth
+++ , chrono::high_resolution_clock::duration propagation_delay
+++ , int max_queue_size, std::string name = "queue");
+++
+++ virtual void incoming_packet(aux::packet p) override final;
+++
+++ virtual std::string label() const override final;
+++
+++ queue(queue const&) = delete;
+++ queue& operator=(queue const&) = delete;
+++
+++ queue(queue&&) = default;
+++ queue& operator=(queue&&) = delete;
+++
+++ private:
+++
+++ void begin_send_next_packet();
+++ void next_packet_sent();
+++
+++ // the queue can't hold more than this number of bytes. Once it's full,
+++ // any new packets arriving will be dropped (tail drop)
+++ int m_max_queue_size;
+++
+++ // the amount of time it takes to forward a packet. Every packet is
+++ // delayed by at least this much before being forwarded
+++ chrono::high_resolution_clock::duration m_forwarding_latency;
+++
+++ // the number of bytes per second that can be sent. This includes the
+++ // packet overhead
+++ int m_bandwidth;
+++
+++ // the number of bytes currently in the packet queue
+++ int m_queue_size;
+++
+++ std::string m_node_name;
+++
+++ // this is the queue of packets and the time each packet was enqueued
+++ std::deque<timed_packet, aux::mallocator<timed_packet>> m_queue;
+++ asio::high_resolution_timer m_forward_timer;
+++
+++ chrono::high_resolution_clock::time_point m_last_forward;
+++ };
+++
+++}
+++
+++#ifdef _MSC_VER
+++#pragma warning(pop)
+++#endif
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/simulator.hpp
++@@ -0,0 +1,1486 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef SIMULATOR_HPP_INCLUDED
+++#define SIMULATOR_HPP_INCLUDED
+++
+++#include "simulator/push_warnings.hpp"
+++
+++#include <boost/config.hpp>
+++#include <boost/asio/detail/config.hpp>
+++#include <boost/asio/basic_deadline_timer.hpp>
+++#include <boost/asio/ip/udp.hpp>
+++#include <boost/asio/ip/tcp.hpp>
+++#include <boost/asio/write.hpp>
+++#include <boost/asio/read.hpp>
+++#include <boost/asio/io_context.hpp>
+++#include <boost/system/error_code.hpp>
+++#include <boost/asio/ip/network_v4.hpp>
+++#include <boost/asio/buffers_iterator.hpp>
+++
+++#include <boost/asio/post.hpp>
+++#include <boost/asio/defer.hpp>
+++#include <boost/asio/dispatch.hpp>
+++#include <boost/asio/error.hpp>
+++
+++// only for boost::beast::role_type, used by the teardown()/async_teardown()
+++// overloads below (customization points boost::beast::websocket::stream
+++// needs for any non-boost::asio socket type it's instantiated over); this
+++// is the single lightweight header that defines it, not a dependency on
+++// beast's websocket/http machinery.
+++#include <boost/beast/core/role.hpp>
+++
+++#include <boost/optional.hpp>
+++
+++#include "simulator/pop_warnings.hpp"
+++
+++#include "simulator/chrono.hpp"
+++#include "simulator/sink_forwarder.hpp"
+++#include "simulator/function.hpp"
+++#include "simulator/noexcept_movable.hpp"
+++#include "simulator/mallocator.hpp"
+++
+++#include <deque>
+++#include <memory>
+++#include <mutex>
+++#include <map>
+++#include <unordered_map>
+++#include <unordered_set>
+++#include <set>
+++#include <vector>
+++#include <list>
+++#include <functional>
+++#include <utility>
+++
+++#ifndef IP_DONTFRAGMENT
+++#define IP_DONTFRAGMENT 1
+++#endif
+++
+++namespace sim
+++{
+++ namespace aux
+++ {
+++ struct channel;
+++ struct packet;
+++ struct pcap;
+++
+++ // this is outgoing NIC bandwidth
+++ constexpr int nic_bandwidth = 100000000; // 100 MB/s
+++ }
+++
+++ // this represents a network route (a series of sinks to pass a packet
+++ // through)
+++ struct SIMULATOR_DECL route
+++ {
+++ friend route operator+(route lhs, route rhs)
+++ { return std::move(lhs.append(std::move(rhs))); }
+++
+++ std::shared_ptr<sink> next_hop() const { return hops.front(); }
+++ std::shared_ptr<sink> pop_front()
+++ {
+++ if (hops.empty()) return std::shared_ptr<sink>();
+++ std::shared_ptr<sink> ret(std::move(hops.front()));
+++ hops.erase(hops.begin());
+++ return ret;
+++ }
+++ void replace_last(std::shared_ptr<sink> s) { hops.back() = std::move(s); }
+++ void prepend(route const& r)
+++ { hops.insert(hops.begin(), r.hops.begin(), r.hops.end()); }
+++ void prepend(std::shared_ptr<sink> s) { hops.insert(hops.begin(), std::move(s)); }
+++ route& append(route const& r)
+++ { hops.insert(hops.end(), r.hops.begin(), r.hops.end()); return *this; }
+++ route& append(std::shared_ptr<sink> s) { hops.push_back(std::move(s)); return *this; }
+++ bool empty() const { return hops.empty(); }
+++ std::shared_ptr<sink> last() const
+++ { return hops.back(); }
+++
+++ private:
+++ std::deque<std::shared_ptr<sink>, aux::mallocator<std::shared_ptr<sink>>> hops;
+++ };
+++
+++ void forward_packet(aux::packet p);
+++
+++ struct simulation;
+++ struct configuration;
+++ struct queue;
+++
+++ namespace asio
+++ {
+++
+++ using boost::asio::buffer_size;
+++ using boost::asio::const_buffer;
+++ using boost::asio::mutable_buffer;
+++ using boost::asio::buffer;
+++
+++ // brought in here (rather than relying on ADL at each call site below)
+++ // so buffer sequence types whose associated namespaces don't include
+++ // boost::asio (e.g. boost::beast's internal buffer sequence types) are
+++ // still found; the "using" also participates in ADL's overload set at
+++ // the point of an unqualified call, so this doesn't shadow lookups for
+++ // types that do live in boost::asio.
+++ using boost::asio::buffer_sequence_begin;
+++ using boost::asio::buffer_sequence_end;
+++
+++ using boost::asio::post;
+++ using boost::asio::dispatch;
+++ using boost::asio::defer;
+++
+++ struct io_context;
+++
+++ struct io_executor
+++ {
+++ io_executor(io_context& ctx) : m_ctx(&ctx) {}
+++ io_context& context() const { return *m_ctx; }
+++
+++ template <typename Handler, typename Allocator>
+++ void dispatch(Handler handler, Allocator const& a) const;
+++
+++ template <typename Handler, typename Allocator>
+++ void post(Handler handler, Allocator const& a) const;
+++
+++ template <typename Handler, typename Allocator>
+++ void defer(Handler handler, Allocator const& a) const;
+++
+++ void on_work_finished() const {}
+++ void on_work_started() const {}
+++
+++ bool running_in_this_thread() const { return true; }
+++
+++ friend bool operator==(io_executor const& lhs, io_executor const& rhs)
+++ { return lhs.m_ctx == rhs.m_ctx; }
+++
+++ friend bool operator!=(io_executor const& lhs, io_executor const& rhs)
+++ { return lhs.m_ctx != rhs.m_ctx; }
+++
+++ private:
+++ io_context* m_ctx;
+++ };
+++
+++ struct SIMULATOR_DECL high_resolution_timer
+++ {
+++ friend struct sim::simulation;
+++
+++ using time_type = chrono::high_resolution_clock::time_point;
+++ using duration_type = chrono::high_resolution_clock::duration;
+++
+++ using executor_type = io_executor;
+++ executor_type get_executor();
+++
+++ explicit high_resolution_timer(io_context& io_context);
+++ high_resolution_timer(io_context& io_context,
+++ const time_type& expiry_time);
+++ high_resolution_timer(io_context& io_context,
+++ const duration_type& expiry_time);
+++ high_resolution_timer(high_resolution_timer&&) noexcept = default;
+++ high_resolution_timer& operator=(high_resolution_timer&&) noexcept = default;
+++ ~high_resolution_timer();
+++
+++ std::size_t cancel();
+++ std::size_t cancel_one();
+++
+++ time_type expiry() const;
+++ std::size_t expires_at(const time_type& expiry_time);
+++ std::size_t expires_after(const duration_type& expiry_time);
+++
+++ void wait();
+++ void wait(boost::system::error_code& ec);
+++
+++ void async_wait(aux::function<void(boost::system::error_code const&)> handler);
+++
+++ private:
+++
+++ void fire(boost::system::error_code ec);
+++
+++ time_type m_expiration_time;
+++ aux::function<void(boost::system::error_code const&)> m_handler;
+++ io_context* m_io_service;
+++ bool m_expired;
+++ };
+++
+++ using waitable_timer = high_resolution_timer;
+++
+++ namespace error = boost::asio::error;
+++
+++ template <typename Protocol>
+++ struct socket_base
+++ {
+++ socket_base(io_context& ios) : m_io_service(ios) {}
+++ socket_base(socket_base&& s) = default;
+++
+++ enum wait_type_t
+++ {
+++ wait_read, wait_write, wait_error
+++ };
+++
+++ // alias matching the name used by boost.asio's basic_socket::wait_type,
+++ // for code that's written against both APIs
+++ using wait_type = wait_type_t;
+++
+++ // io_control
+++ using reuse_address = boost::asio::socket_base::reuse_address;
+++ using executor_type = io_executor;
+++ executor_type get_executor();
+++
+++ // socket options
+++ using send_buffer_size = boost::asio::socket_base::send_buffer_size;
+++ using receive_buffer_size = boost::asio::socket_base::receive_buffer_size;
+++
+++ template <class Option>
+++ void set_option(Option const& opt, boost::system::error_code&)
+++ {
+++ Protocol const p = Protocol::v4();
+++ (void)p;
+++#ifdef IP_DONTFRAG
+++ if (opt.name(p) == IP_DONTFRAG)
+++ m_dont_fragment = *reinterpret_cast<int const*>(opt.data(p)) != 0;
+++#endif
+++#ifdef IP_DONTFRAGMENT
+++ if (opt.name(p) == IP_DONTFRAGMENT)
+++ m_dont_fragment = *reinterpret_cast<int const*>(opt.data(p)) != 0;
+++#endif
+++#ifdef IP_MTU_DISCOVER
+++ if (opt.name(p) == IP_MTU_DISCOVER)
+++ m_dont_fragment = *reinterpret_cast<int const*>(opt.data(p)) == IP_PMTUDISC_DO;
+++#endif
+++ }
+++
+++ void set_option(receive_buffer_size const& op, boost::system::error_code&)
+++ {
+++ m_max_receive_queue_size = op.value();
+++ }
+++
+++ void set_option(send_buffer_size const& op, boost::system::error_code&)
+++ {
+++ // this limit is specified in microseconds. Given the line rate of
+++ // nic_bandwidth, this is the time it takes to send the specified number
+++ // of bytes.
+++ m_send_queue_time = chrono::microseconds(std::int64_t(double(op.value()) * 1000000.0 / double(aux::nic_bandwidth)));
+++ }
+++
+++ void set_option(reuse_address const&, boost::system::error_code&)
+++ {
+++ // TODO: implement
+++ }
+++
+++ typename Protocol::endpoint local_endpoint(boost::system::error_code& ec) const
+++ {
+++ if (!m_open)
+++ {
+++ ec = error::bad_descriptor;
+++ return typename Protocol::endpoint{};
+++ }
+++
+++ return m_user_bound_to;
+++ }
+++
+++ typename Protocol::endpoint local_endpoint() const
+++ {
+++ boost::system::error_code ec;
+++ auto const ret = local_endpoint(ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ return ret;
+++ }
+++
+++ typename Protocol::endpoint local_bound_to(boost::system::error_code& ec) const
+++ {
+++ if (!m_open)
+++ {
+++ ec = error::bad_descriptor;
+++ return typename Protocol::endpoint{};
+++ }
+++
+++ return m_bound_to;
+++ }
+++
+++ typename Protocol::endpoint local_bound_to() const
+++ {
+++ boost::system::error_code ec;
+++ auto const ret = local_bound_to(ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ return ret;
+++ }
+++
+++ template <class Option>
+++ void get_option(Option&, boost::system::error_code&) { }
+++
+++ void get_option(receive_buffer_size& op, boost::system::error_code&)
+++ {
+++ op = m_max_receive_queue_size;
+++ }
+++
+++ template <class IoControl>
+++ void io_control(IoControl const&, boost::system::error_code&) { }
+++
+++ template <class IoControl>
+++ void io_control(IoControl const&) {}
+++
+++ void non_blocking(bool b, boost::system::error_code&)
+++ { m_non_blocking = b; }
+++
+++ void non_blocking(bool b)
+++ { m_non_blocking = b; }
+++
+++ bool is_open() const
+++ {
+++ return m_open;
+++ }
+++
+++ using message_flags = int;
+++
+++ // internal interface
+++
+++ route get_incoming_route();
+++ route get_outgoing_route();
+++
+++ protected:
+++
+++ io_context& m_io_service;
+++
+++ typename Protocol::endpoint m_bound_to;
+++
+++ // this is the interface the user requested to bind to (in order to
+++ // distinguish the concrete interface it was bound to and INADDR_ANY if
+++ // that was requested). We keep this separately to return it as the local
+++ // endpoint
+++ typename Protocol::endpoint m_user_bound_to;
+++
+++ // this is an object implementing the sink interface, forwarding
+++ // packets to this socket. If this socket is destructed, this forwarder
+++ // is redirected to just drop packets. This is necessary since sinks
+++ // must be held by shared_ptr, and socket objects aren't.
+++ std::shared_ptr<aux::sink_forwarder> m_forwarder;
+++
+++ // whether the socket is open or not
+++ bool m_open = false;
+++
+++ // true if the socket is set to non-blocking mode
+++ bool m_non_blocking = false;
+++
+++ // when true, the MTU limit is in effect
+++ bool m_dont_fragment = false;
+++
+++ // the max size of the incoming queue. This is to emulate the send and
+++ // receive buffer. This should also depend on the bandwidth, to not
+++ // make the queue size not grow too long in time.
+++ int m_max_receive_queue_size = 64 * 1024;
+++
+++ // the number of microseconds worth of send buffer this socket has, at
+++ // NIC linerate.
+++ chrono::microseconds m_send_queue_time{200000};
+++ };
+++
+++ namespace ip {
+++
+++ using boost::asio::ip::address;
+++ using boost::asio::ip::address_v4;
+++ using boost::asio::ip::address_v6;
+++
+++ using boost::asio::ip::make_address_v4;
+++ using boost::asio::ip::make_address_v6;
+++ using boost::asio::ip::make_address;
+++
+++ using boost::asio::ip::make_network_v4;
+++
+++ template<typename Protocol>
+++ struct basic_endpoint : boost::asio::ip::basic_endpoint<Protocol>
+++ {
+++ basic_endpoint(ip::address const& addr, unsigned short port)
+++ : boost::asio::ip::basic_endpoint<Protocol>(addr, port) {}
+++ basic_endpoint() : boost::asio::ip::basic_endpoint<Protocol>() {}
+++ };
+++
+++ template <typename Protocol>
+++ struct basic_resolver_entry
+++ {
+++ using endpoint_type = typename Protocol::endpoint;
+++ using protocol_type = Protocol;
+++
+++ basic_resolver_entry() {}
+++ basic_resolver_entry(
+++ endpoint_type const& ep
+++ , std::string const& host
+++ , std::string const& service)
+++ : m_endpoint(ep)
+++ , m_host_name(host)
+++ , m_service(service)
+++ {}
+++
+++ endpoint_type endpoint() const { return m_endpoint; }
+++ std::string host_name() const { return m_host_name; }
+++ operator endpoint_type() const { return m_endpoint; }
+++ std::string service_name() const { return m_service; }
+++
+++ private:
+++ endpoint_type m_endpoint;
+++ std::string m_host_name;
+++ std::string m_service;
+++ };
+++
+++ template<typename Protocol>
+++ struct SIMULATOR_DECL basic_resolver
+++ {
+++ basic_resolver(io_context& ios);
+++
+++ using protocol_type = Protocol;
+++ using results_type = std::vector<basic_resolver_entry<Protocol>, aux::mallocator<basic_resolver_entry<Protocol>>>;
+++
+++ void cancel();
+++
+++ void async_resolve(std::string hostname, char const* service
+++ , aux::function<void(boost::system::error_code const&,
+++ results_type)> handler);
+++
+++ basic_resolver(basic_resolver&&) noexcept;
+++ basic_resolver& operator=(basic_resolver&&) noexcept;
+++ basic_resolver(basic_resolver const&) = delete;
+++ basic_resolver& operator=(basic_resolver const&) = delete;
+++
+++ //TODO: add remaining members
+++
+++ private:
+++
+++ void on_lookup(boost::system::error_code const& ec);
+++
+++ struct result_t
+++ {
+++ chrono::high_resolution_clock::time_point completion_time;
+++ boost::system::error_code err;
+++ results_type ips;
+++ aux::function<void(boost::system::error_code const&,
+++ results_type)> handler;
+++
+++ result_t(
+++ chrono::high_resolution_clock::time_point ct
+++ , boost::system::error_code e
+++ , results_type ips_
+++ , aux::function<void(boost::system::error_code const&
+++ , results_type)> h)
+++ : completion_time(ct)
+++ , err(e)
+++ , ips(std::move(ips_))
+++ , handler(std::move(h))
+++ {}
+++
+++ result_t(result_t&&) noexcept = default;
+++ result_t& operator=(result_t&&) = default;
+++ result_t(result_t const&) = delete;
+++ result_t& operator=(result_t const&) = delete;
+++ };
+++
+++ io_context* m_ios;
+++ asio::high_resolution_timer m_timer;
+++ using queue_t = aux::noexcept_movable<std::vector<result_t>>;
+++
+++ queue_t m_queue;
+++ };
+++
+++ struct SIMULATOR_DECL udp
+++ {
+++ static udp v4() { return udp(AF_INET); }
+++ static udp v6() { return udp(AF_INET6); }
+++
+++ using endpoint = basic_endpoint<udp>;
+++
+++ struct SIMULATOR_DECL socket : socket_base<udp>, sink
+++ {
+++ using endpoint_type = ip::udp::endpoint;
+++ using protocol_type = ip::udp;
+++ using lowest_layer_type = socket;
+++
+++ socket(io_context& ios);
+++ ~socket() override;
+++
+++ socket(socket const&) = delete;
+++ socket& operator=(socket const&) = delete;
+++ socket(socket&&);
+++
+++ lowest_layer_type& lowest_layer() { return *this; }
+++
+++ void bind(ip::udp::endpoint const& ep
+++ , boost::system::error_code& ec);
+++ void bind(ip::udp::endpoint const& ep);
+++
+++ void close();
+++ void close(boost::system::error_code& ec);
+++
+++ void cancel(boost::system::error_code& ec);
+++ void cancel();
+++
+++ void open(udp protocol, boost::system::error_code& ec);
+++ void open(udp protocol);
+++
+++ template<typename ConstBufferSequence>
+++ std::size_t send_to(ConstBufferSequence const& bufs
+++ , udp::endpoint const& destination
+++ , socket_base::message_flags flags
+++ , boost::system::error_code& ec)
+++ {
+++ std::vector<asio::const_buffer> b(buffer_sequence_begin(bufs)
+++ , buffer_sequence_end(bufs));
+++ abort_send_handlers();
+++ return send_to_impl(b, destination, flags, ec);
+++ }
+++
+++ template<typename ConstBufferSequence>
+++ std::size_t send_to(ConstBufferSequence const& bufs
+++ , udp::endpoint const& destination)
+++ {
+++ std::vector<asio::const_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+++ abort_send_handlers();
+++ boost::system::error_code ec;
+++ std::size_t ret = send_to_impl(b, destination, 0, ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ return ret;
+++ }
+++
+++ void async_wait(socket_base::wait_type_t w
+++ , aux::function<void(boost::system::error_code const&)> handler);
+++
+++ template <class BufferSequence>
+++ void async_receive(BufferSequence const& bufs
+++ , aux::function<void(boost::system::error_code const&
+++ , std::size_t)> handler)
+++ {
+++ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+++ abort_recv_handlers();
+++
+++ async_receive_from_impl(b, nullptr, 0, std::move(handler));
+++ }
+++
+++ template <class BufferSequence>
+++ void async_receive_from(BufferSequence const& bufs
+++ , udp::endpoint& sender
+++ , aux::function<void(boost::system::error_code const&
+++ , std::size_t)> handler)
+++ {
+++ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+++ abort_recv_handlers();
+++
+++ async_receive_from_impl(b, &sender, 0, std::move(handler));
+++ }
+++
+++ template <class BufferSequence>
+++ void async_receive_from(BufferSequence const& bufs
+++ , udp::endpoint& sender
+++ , socket_base::message_flags flags
+++ , aux::function<void(boost::system::error_code const&
+++ , std::size_t)> handler)
+++ {
+++ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+++ abort_recv_handlers();
+++
+++ async_receive_from_impl(b, &sender, flags, std::move(handler));
+++ }
+++/*
+++ void async_read_from(null_buffers const&
+++ , aux::function<void(boost::system::error_code const&
+++ , std::size_t)> handler)
+++ {
+++ abort_recv_handlers();
+++ async_read_some_null_buffers_impl(std::move(handler));
+++ }
+++*/
+++
+++ template <class BufferSequence>
+++ std::size_t receive_from(BufferSequence const& bufs
+++ , udp::endpoint& sender)
+++ {
+++ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+++ assert(!b.empty());
+++ abort_recv_handlers();
+++ boost::system::error_code ec;
+++ std::size_t ret = receive_from_impl(b, &sender, 0, ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ return ret;
+++ }
+++
+++ template <class BufferSequence>
+++ std::size_t receive_from(BufferSequence const& bufs
+++ , udp::endpoint& sender
+++ , socket_base::message_flags)
+++ {
+++ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+++ assert(!b.empty());
+++ abort_recv_handlers();
+++ boost::system::error_code ec;
+++ std::size_t ret = receive_from_impl(b, &sender, 0, ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ return ret;
+++ }
+++
+++ template <class BufferSequence>
+++ std::size_t receive_from(BufferSequence const& bufs
+++ , udp::endpoint& sender
+++ , socket_base::message_flags
+++ , boost::system::error_code& ec)
+++ {
+++ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+++ assert(!b.empty());
+++ abort_recv_handlers();
+++ return receive_from_impl(b, &sender, 0, ec);
+++ }
+++
+++ // TODO: support connect and remote_endpoint
+++
+++ // internal interface
+++
+++ // implements sink
+++ virtual void incoming_packet(aux::packet p) override final;
+++ virtual std::string label() const override final
+++ { return m_bound_to.address().to_string(); }
+++
+++ void async_receive_from_impl(std::vector<asio::mutable_buffer> const& bufs
+++ , udp::endpoint* sender
+++ , socket_base::message_flags flags
+++ , aux::function<void(boost::system::error_code const&
+++ , std::size_t)> handler);
+++
+++ std::size_t receive_from_impl(
+++ std::vector<asio::mutable_buffer> const& bufs
+++ , udp::endpoint* sender
+++ , socket_base::message_flags flags
+++ , boost::system::error_code& ec);
+++
+++ void async_wait_receive_impl(
+++ udp::endpoint* sender
+++ , aux::function<void(boost::system::error_code const&)> handler);
+++
+++ private:
+++
+++ void maybe_wakeup_reader();
+++ void abort_send_handlers();
+++ void abort_recv_handlers();
+++
+++ std::size_t send_to_impl(std::vector<asio::const_buffer> const& b
+++ , udp::endpoint const& dst, message_flags flags
+++ , boost::system::error_code& ec);
+++
+++ // this is the next time we'll have an opportunity to send another
+++ // outgoing packet. This is used to implement the bandwidth constraints
+++ // of channels. This may be in the past, in which case it's OK to send
+++ // a packet immediately.
+++ chrono::high_resolution_clock::time_point m_next_send;
+++
+++ // while we're blocked in an async_write_some operation, this is the
+++ // handler that should be called once we're done sending
+++ aux::function<void(boost::system::error_code const&, std::size_t)>
+++ m_send_handler;
+++ aux::function<void(boost::system::error_code const&)>
+++ m_wait_send_handler;
+++
+++ // if we have an outstanding read on this socket, this is set to the
+++ // handler.
+++ aux::function<void(boost::system::error_code const&, std::size_t)>
+++ m_recv_handler;
+++ aux::function<void(boost::system::error_code const&)>
+++ m_wait_recv_handler;
+++
+++ // if we have an outstanding read operation, this is the buffer to
+++ // receive into
+++ std::vector<asio::mutable_buffer> m_recv_buffer;
+++
+++ // if we have an outstanding receive operation, this may point to an
+++ // endpoint to fill in the senders IP in
+++ udp::endpoint* m_recv_sender;
+++
+++ asio::high_resolution_timer m_recv_timer;
+++ asio::high_resolution_timer m_send_timer;
+++
+++ // this is the incoming queue of packets for each socket
+++ std::list<aux::packet, aux::mallocator<aux::packet>> m_incoming_queue;
+++
+++ bool m_recv_null_buffers;
+++
+++ // the number of bytes in the incoming packet queue
+++ int m_queue_size;
+++
+++ // our address family
+++ bool m_is_v4;
+++ };
+++
+++ using resolver = basic_resolver<udp>;
+++
+++ int family() const { return m_family; }
+++
+++ friend bool operator==(udp const& lhs, udp const& rhs)
+++ { return lhs.m_family == rhs.m_family; }
+++
+++ friend bool operator!=(udp const& lhs, udp const& rhs)
+++ { return lhs.m_family != rhs.m_family; }
+++
+++ private:
+++ // Construct with a specific family.
+++ explicit udp(int protocol_family)
+++ : m_family(protocol_family)
+++ {}
+++
+++ int m_family;
+++
+++ }; // udp
+++
+++ struct SIMULATOR_DECL tcp
+++ {
+++ // temporary fix until the resolvers are implemented using our endpoint
+++ tcp(boost::asio::ip::tcp p) : m_family(p.family()) {}
+++
+++ static tcp v4() { return tcp(AF_INET); }
+++ static tcp v6() { return tcp(AF_INET6); }
+++
+++ int family() const { return m_family; }
+++
+++ using endpoint = basic_endpoint<tcp>;
+++
+++ struct SIMULATOR_DECL socket : socket_base<tcp>, sink
+++ {
+++ using endpoint_type = ip::tcp::endpoint;
+++ using protocol_type = ip::tcp;
+++ using lowest_layer_type = socket;
+++
+++ explicit socket(io_context& ios);
+++ socket(socket const&) = delete;
+++ socket& operator=(socket const&) = delete;
+++ socket(socket&&);
+++ socket& operator=(socket&&);
+++
+++ ~socket() override;
+++
+++ void close();
+++ void close(boost::system::error_code& ec);
+++ void open(tcp protocol, boost::system::error_code& ec);
+++ void open(tcp protocol);
+++ void bind(ip::tcp::endpoint const& ep
+++ , boost::system::error_code& ec);
+++ void bind(ip::tcp::endpoint const& ep);
+++ tcp::endpoint remote_endpoint(boost::system::error_code& ec) const;
+++ tcp::endpoint remote_endpoint() const;
+++
+++ lowest_layer_type& lowest_layer() { return *this; }
+++
+++ void async_connect(tcp::endpoint const& target
+++ , aux::function<void(boost::system::error_code const&)> h);
+++
+++ template <class ConstBufferSequence>
+++ void async_write_some(ConstBufferSequence const& bufs
+++ , aux::function<void(boost::system::error_code const&
+++ , std::size_t)> handler)
+++ {
+++ std::vector<asio::const_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+++ abort_send_handlers();
+++ async_write_some_impl(b, std::move(handler));
+++ }
+++
+++ void async_wait(socket_base::wait_type_t const w
+++ , aux::function<void(boost::system::error_code const&)> handler)
+++ {
+++ if (w == socket_base::wait_type_t::wait_write)
+++ {
+++ abort_send_handlers();
+++ async_wait_write_impl(std::move(handler));
+++ }
+++ else if (w == socket_base::wait_type_t::wait_read)
+++ {
+++ abort_recv_handlers();
+++ async_wait_read_impl(std::move(handler));
+++ }
+++ }
+++
+++ template <class BufferSequence>
+++ std::size_t read_some(BufferSequence const& bufs
+++ , boost::system::error_code& ec)
+++ {
+++ assert(m_non_blocking && "blocking operations not supported");
+++ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+++ return read_some_impl(b, ec);
+++ }
+++
+++ template <class ConstBufferSequence>
+++ std::size_t write_some(ConstBufferSequence const& bufs
+++ , boost::system::error_code& ec)
+++ {
+++ assert(m_non_blocking && "blocking operations not supported");
+++ std::vector<asio::const_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+++ return write_some_impl(b, ec);
+++ }
+++
+++ template <class BufferSequence>
+++ void async_read_some(BufferSequence const& bufs
+++ , aux::function<void(boost::system::error_code const&
+++ , std::size_t)> handler)
+++ {
+++ std::vector<asio::mutable_buffer> b(buffer_sequence_begin(bufs), buffer_sequence_end(bufs));
+++ abort_recv_handlers();
+++
+++ async_read_some_impl(b, std::move(handler));
+++ }
+++
+++ std::size_t available(boost::system::error_code & ec) const;
+++ std::size_t available() const;
+++
+++ void cancel(boost::system::error_code& ec);
+++ void cancel();
+++
+++ using socket_base::set_option;
+++ using socket_base::get_option;
+++ using socket_base::io_control;
+++
+++ // private interface
+++
+++ // implements sink
+++ virtual void incoming_packet(aux::packet p) override;
+++ virtual std::string label() const override final
+++ { return m_bound_to.address().to_string(); }
+++
+++ void internal_connect(tcp::endpoint const& bind_ip
+++ , std::shared_ptr<aux::channel> const& c
+++ , boost::system::error_code& ec);
+++
+++ void abort_send_handlers();
+++ void abort_recv_handlers();
+++
+++ virtual bool internal_is_listening();
+++ protected:
+++
+++ void maybe_wakeup_reader();
+++ void maybe_wakeup_writer();
+++
+++ void async_write_some_impl(std::vector<asio::const_buffer> const& bufs
+++ , aux::function<void(boost::system::error_code const&, std::size_t)> handler);
+++ void async_read_some_impl(std::vector<asio::mutable_buffer> const& bufs
+++ , aux::function<void(boost::system::error_code const&, std::size_t)> handler);
+++ void async_wait_read_impl(
+++ aux::function<void(boost::system::error_code const&)> handler);
+++ void async_wait_write_impl(
+++ aux::function<void(boost::system::error_code const&)> handler);
+++ std::size_t write_some_impl(std::vector<asio::const_buffer> const& bufs
+++ , boost::system::error_code& ec);
+++ std::size_t read_some_impl(std::vector<asio::mutable_buffer> const& bufs
+++ , boost::system::error_code& ec);
+++
+++ void send_packet(aux::packet p);
+++
+++ // called when a packet is dropped
+++ void packet_dropped(aux::packet p);
+++
+++ aux::function<void(boost::system::error_code const&)> m_connect_handler;
+++
+++ asio::high_resolution_timer m_connect_timer;
+++
+++ // the tcp "packet size" (segment size)
+++ // TODO: name this constant!
+++ int m_mss = 1475;
+++
+++ // while we're blocked in an async_write_some operation, this is the
+++ // handler that should be called once we're done sending
+++ aux::function<void(boost::system::error_code const&, std::size_t)> m_send_handler;
+++ aux::function<void(boost::system::error_code const&)> m_wait_send_handler;
+++
+++ std::vector<asio::const_buffer> m_send_buffer;
+++
+++ // this is the incoming queue of packets for each socket
+++ std::list<aux::packet, aux::mallocator<aux::packet>> m_incoming_queue;
+++
+++ // the number of bytes in the incoming packet queue
+++ int m_queue_size = 0;
+++
+++ // if we have an outstanding read on this socket, this is set to the
+++ // handler.
+++ aux::function<void(boost::system::error_code const&, std::size_t)> m_recv_handler;
+++ aux::function<void(boost::system::error_code const&)> m_wait_recv_handler;
+++
+++ // if we have an outstanding buffer to receive into, these are them
+++ std::vector<asio::mutable_buffer> m_recv_buffer;
+++
+++ asio::high_resolution_timer m_recv_timer;
+++
+++ // our address family
+++ bool m_is_v4 = true;
+++
+++ // true if the currently outstanding read operation is for null_buffers
+++ bool m_recv_null_buffers = false;
+++
+++ // true if the currenly outstanding write operation is for null_buffers
+++ bool m_send_null_buffers = false;
+++
+++ // if this socket is connected to another endpoint, this object is
+++ // shared between both sockets and contain information and state about
+++ // the channel.
+++ std::shared_ptr<aux::channel> m_channel;
+++
+++ std::uint64_t m_next_outgoing_seq = 0;
+++ std::uint64_t m_next_incoming_seq = 0;
+++
+++ // the sequence number of the last dropped packet. We should only cut
+++ // the cwnd in half once per round-trip. If a whole window is lost, we
+++ // need to only halve it once
+++ std::uint64_t m_last_drop_seq = 0;
+++
+++ // the current congestion window size (in bytes)
+++ int m_cwnd = m_mss * 2;
+++
+++ // the number of bytes that have been sent but not ACKed yet
+++ int m_bytes_in_flight = 0;
+++
+++ // reorder buffer for when packets are dropped
+++ std::map<std::uint64_t, aux::packet, std::less<std::uint64_t>, aux::mallocator<std::pair<std::uint64_t const, aux::packet>>> m_reorder_buffer;
+++
+++ // the sizes of packets given their sequence number
+++ std::unordered_map<std::uint64_t, int, std::hash<std::uint64_t>, std::equal_to<std::uint64_t>, aux::mallocator<std::pair<std::uint64_t const, int>>> m_outstanding_packet_sizes;
+++
+++ // packets to re-send (because they were dropped)
+++ std::list<aux::packet, aux::mallocator<aux::packet>> m_outgoing_packets;
+++ };
+++
+++ struct SIMULATOR_DECL acceptor : socket
+++ {
+++ explicit acceptor(io_context& ios);
+++ acceptor(acceptor&&);
+++ ~acceptor() override;
+++
+++ void cancel(boost::system::error_code& ec);
+++ void cancel();
+++
+++ void listen(int qs = -1);
+++ void listen(int qs, boost::system::error_code& ec);
+++
+++ void async_accept(ip::tcp::socket& peer
+++ , aux::function<void(boost::system::error_code const&)> h);
+++ void async_accept(ip::tcp::socket& peer
+++ , ip::tcp::endpoint& peer_endpoint
+++ , aux::function<void(boost::system::error_code const&)> h);
+++ void async_accept(aux::function<void(boost::system::error_code const&, ip::tcp::socket peer)> h);
+++
+++ void close(boost::system::error_code& ec);
+++ void close();
+++
+++ // private interface
+++
+++ // implements sink
+++ virtual void incoming_packet(aux::packet p) override final;
+++ virtual bool internal_is_listening() override final;
+++
+++ private:
+++ // check the incoming connection queue to see if any connection in
+++ // there is ready to be accepted and delivered to the user
+++ void check_accept_queue();
+++ void do_check_accept_queue(boost::system::error_code const& ec);
+++
+++ aux::function<void(boost::system::error_code const&)> m_accept_handler;
+++ aux::function<void(boost::system::error_code const&, ip::tcp::socket)> m_accept_handler2;
+++
+++ // the number of half-open incoming connections this listen socket can
+++ // hold. If this is -1, this socket is not yet listening and incoming
+++ // connection attempts should be rejected.
+++ int m_queue_size_limit;
+++
+++ // these are incoming connection attempts. Both half-open and
+++ // completely connected. When accepting a connection, this queue is
+++ // checked first before waiting for a connection attempt.
+++ using incoming_conns_t = std::vector<std::shared_ptr<aux::channel>, aux::mallocator<std::shared_ptr<aux::channel>>>;
+++ incoming_conns_t m_incoming_conns;
+++
+++ // for new-style accept, allocate socket in here just to fail early
+++ boost::optional<ip::tcp::socket> m_new_socket;
+++
+++ // the socket to accept a connection into
+++ tcp::socket* m_accept_into;
+++
+++ // the endpoint to write the remote endpoint into when accepting
+++ tcp::endpoint* m_remote_endpoint;
+++
+++ // non copyable
+++ acceptor(acceptor const&);
+++ acceptor& operator=(acceptor const&);
+++ };
+++
+++ using resolver = basic_resolver<tcp>;
+++
+++ friend bool operator==(tcp const& lhs, tcp const& rhs)
+++ { return lhs.m_family == rhs.m_family; }
+++
+++ friend bool operator!=(tcp const& lhs, tcp const& rhs)
+++ { return lhs.m_family != rhs.m_family; }
+++
+++ private:
+++ // Construct with a specific family.
+++ explicit tcp(int protocol_family)
+++ : m_family(protocol_family)
+++ {}
+++
+++ int m_family;
+++ };
+++
+++ extern template struct basic_resolver<udp>;
+++ extern template struct basic_resolver<tcp>;
+++
+++ // boost::beast looks up a close function for a socket-like type via
+++ // unqualified lookup + ADL under the name "beast_close_socket" (see
+++ // boost/beast/core/stream_traits.hpp); this satisfies that customization
+++ // point for tcp::socket - it's just a free function beast's ADL-based
+++ // lookup will find because it lives in tcp::socket's own namespace, so
+++ // beast::websocket::stream<tcp::socket> doesn't need this header to
+++ // declare it inside boost::beast itself.
+++ inline void beast_close_socket(tcp::socket& s)
+++ {
+++ boost::system::error_code ec;
+++ s.close(ec);
+++ }
+++
+++ // same idea for the teardown()/async_teardown() customization points
+++ // boost::beast::websocket::stream<Socket> looks up (via ADL, from
+++ // boost::beast::websocket) for any Socket type it's instantiated over
+++ // that isn't a boost::asio socket -- see
+++ // boost/beast/websocket/teardown.hpp. tcp::socket has no half-close/
+++ // non-blocking read-drain support to mirror the real graceful-shutdown
+++ // sequence those implement for a real socket, so this just closes it;
+++ // that's sufficient for driving deterministic test scenarios, which is
+++ // the only thing this socket type is ever used for.
+++ inline void teardown(boost::beast::role_type, tcp::socket& s, boost::system::error_code& ec)
+++ {
+++ s.close(ec);
+++ }
+++
+++ template <class Handler>
+++ void async_teardown(boost::beast::role_type, tcp::socket& s, Handler&& handler)
+++ {
+++ boost::system::error_code ec;
+++ s.close(ec);
+++ boost::asio::post(s.get_executor(), std::bind(std::forward<Handler>(handler), ec));
+++ }
+++
+++ } // ip
+++
+++ // mirrors (a subset of) boost::asio::async_connect(socket, begin, end,
+++ // handler): tries each endpoint in the range in turn, closing and
+++ // advancing to the next on failure, until one connects or the range is
+++ // exhausted. Calls handler(error_code, Iterator) with the iterator that
+++ // succeeded, or the end iterator carrying the last endpoint's error if
+++ // all of them failed. Lives directly in sim::asio, alongside the
+++ // boost::asio free function it mirrors, rather than in sim::asio::ip, so
+++ // that unqualified calls resolve to whichever of the two applies via
+++ // ADL (ip::tcp::socket's base, socket_base<tcp>, is declared in this
+++ // namespace, which is what makes that lookup work).
+++ template <typename Iterator, typename Handler>
+++ void async_connect(ip::tcp::socket& s, Iterator begin, Iterator end, Handler handler)
+++ {
+++ struct op : std::enable_shared_from_this<op>
+++ {
+++ op(ip::tcp::socket& sock, Iterator b, Iterator e, Handler h)
+++ : socket(sock), iter(b), end(e), handler(std::move(h))
+++ {}
+++
+++ void attempt()
+++ {
+++ socket.async_connect(*iter, [self = this->shared_from_this()]
+++ (boost::system::error_code const& ec) { self->on_connect(ec); });
+++ }
+++
+++ void on_connect(boost::system::error_code const& ec)
+++ {
+++ if (ec && std::next(iter) != end)
+++ {
+++ boost::system::error_code ignore;
+++ socket.close(ignore);
+++ ++iter;
+++ attempt();
+++ return;
+++ }
+++
+++ handler(ec, iter);
+++ }
+++
+++ ip::tcp::socket& socket;
+++ Iterator iter;
+++ Iterator end;
+++ Handler handler;
+++ };
+++
+++ if (begin == end)
+++ {
+++ handler(boost::asio::error::make_error_code(boost::asio::error::not_found), end);
+++ return;
+++ }
+++
+++ std::make_shared<op>(s, begin, end, std::move(handler))->attempt();
+++ }
+++
+++ } // asio
+++
+++ struct SIMULATOR_DECL simulation
+++ {
+++ // it calls fire() when a timer fires
+++ friend struct high_resolution_timer;
+++
+++ simulation(configuration& config);
+++ ~simulation();
+++
+++ std::size_t run();
+++
+++ std::size_t poll(boost::system::error_code& ec);
+++ std::size_t poll();
+++
+++ std::size_t poll_one(boost::system::error_code& ec);
+++ std::size_t poll_one();
+++
+++ void stop();
+++ bool stopped() const;
+++ void restart();
+++ // private interface
+++
+++ void add_timer(asio::high_resolution_timer* t);
+++ void remove_timer(asio::high_resolution_timer* t);
+++
+++ boost::asio::io_context& get_internal_service()
+++ { return m_service; }
+++
+++ asio::io_context& get_io_context()
+++ { return *m_internal_ios; }
+++
+++ asio::ip::tcp::endpoint bind_socket(asio::ip::tcp::socket* socket
+++ , asio::ip::tcp::endpoint ep
+++ , boost::system::error_code& ec);
+++ void unbind_socket(asio::ip::tcp::socket* socket
+++ , asio::ip::tcp::endpoint const& ep);
+++ void rebind_socket(asio::ip::tcp::socket* prev, asio::ip::tcp::socket* s, asio::ip::tcp::endpoint ep);
+++
+++ asio::ip::udp::endpoint bind_udp_socket(asio::ip::udp::socket* socket
+++ , asio::ip::udp::endpoint ep
+++ , boost::system::error_code& ec);
+++ void unbind_udp_socket(asio::ip::udp::socket* socket
+++ , asio::ip::udp::endpoint const& ep);
+++ void rebind_udp_socket(asio::ip::udp::socket* socket, asio::ip::udp::endpoint ep);
+++
+++ std::shared_ptr<aux::channel> internal_connect(asio::ip::tcp::socket* s
+++ , asio::ip::tcp::endpoint const& target, boost::system::error_code& ec);
+++
+++ route find_udp_socket(
+++ asio::ip::udp::socket const& socket
+++ , asio::ip::udp::endpoint const& ep);
+++
+++ configuration& config() const { return m_config; }
+++
+++ void add_io_service(asio::io_context* ios);
+++ void remove_io_service(asio::io_context* ios);
+++ std::vector<asio::io_context*> get_all_io_services() const;
+++
+++ aux::pcap* get_pcap() const { return m_pcap.get(); }
+++ void log_pcap(char const* filename);
+++
+++ private:
+++ struct timer_compare
+++ {
+++ bool operator()(asio::high_resolution_timer const* lhs
+++ , asio::high_resolution_timer const* rhs) const
+++ { return lhs->expiry() < rhs->expiry(); }
+++ };
+++
+++ configuration& m_config;
+++
+++ std::unique_ptr<aux::pcap> m_pcap;
+++
+++ // all non-expired timers
+++ std::mutex m_timer_queue_mutex;
+++ using timer_queue_t = std::vector<asio::high_resolution_timer*, aux::mallocator<asio::high_resolution_timer*>>;
+++ timer_queue_t m_timer_queue;
+++
+++ // these are the io services that represent nodes on the network
+++ std::unordered_set<asio::io_context*, std::hash<asio::io_context*>, std::equal_to<asio::io_context*>, aux::mallocator<asio::io_context*>> m_nodes;
+++
+++ using listen_sockets_t = std::map<asio::ip::tcp::endpoint, asio::ip::tcp::socket*>;
+++ using listen_socket_iter_t = listen_sockets_t::iterator;
+++ listen_sockets_t m_listen_sockets;
+++
+++ using udp_sockets_t = std::map<asio::ip::udp::endpoint, asio::ip::udp::socket*>;
+++ using udp_socket_iter_t = udp_sockets_t::iterator;
+++ udp_sockets_t m_udp_sockets;
+++
+++ // used for internal timers. this is a pimpl sine our io_context is
+++ // incomplete at this point
+++ std::unique_ptr<asio::io_context> m_internal_ios;
+++
+++ // the next port to use for an outgoing connection, where the port is not
+++ // specified. We want this to be as unique as possible, to distinguish the
+++ // TCP streams.
+++ std::uint16_t m_next_bind_port = 2000;
+++
+++ bool m_stopped = false;
+++
+++ // underlying message queue
+++ boost::asio::io_context m_service;
+++ };
+++
+++ namespace asio {
+++
+++ using boost::asio::async_write;
+++ using boost::asio::async_read;
+++
+++ // boost.asio compatible io_context class that simulates the network
+++ // and time.
+++ struct SIMULATOR_DECL io_context : boost::asio::execution_context
+++ {
+++ io_context(sim::simulation& sim);
+++ io_context(sim::simulation& sim, ip::address const& ip);
+++ io_context(sim::simulation& sim, std::vector<ip::address> const& ips);
+++ io_context(std::size_t threads_hint = 0);
+++ ~io_context();
+++
+++ // not copyable and non movable (it's not movable because we currently
+++ // keep pointers to the io_context instances in the simulator object)
+++ io_context(io_context const&) = delete;
+++ io_context(io_context&&) = delete;
+++ io_context& operator=(io_context const&) = delete;
+++ io_context& operator=(io_context&&) = delete;
+++
+++ std::size_t run(boost::system::error_code& ec);
+++ std::size_t run();
+++
+++ std::size_t poll(boost::system::error_code& ec);
+++ std::size_t poll();
+++
+++ std::size_t poll_one(boost::system::error_code& ec);
+++ std::size_t poll_one();
+++
+++ template <typename Rep, typename Period>
+++ std::size_t run_for(std::chrono::duration<Rep, Period> const&)
+++ {
+++ assert(false);
+++ return 0;
+++ }
+++
+++ template <typename Rep, typename Period>
+++ std::size_t poll_one_for(std::chrono::duration<Rep, Period> const&)
+++ {
+++ assert(false);
+++ return 0;
+++ }
+++
+++ void stop();
+++ bool stopped() const;
+++ void restart();
+++
+++ template <typename Handler, typename Allocator>
+++ void dispatch_impl(Handler handler, Allocator const& a)
+++ { get_internal_service().get_executor().dispatch(std::move(handler), a); }
+++
+++ template <typename Handler, typename Allocator>
+++ void post_impl(Handler handler, Allocator const& a)
+++ { get_internal_service().get_executor().post(std::move(handler), a); }
+++
+++ template <typename Handler, typename Allocator>
+++ void defer_impl(Handler handler, Allocator const& a)
+++ { get_internal_service().get_executor().defer(std::move(handler), a); }
+++
+++ // internal interface
+++ boost::asio::io_context& get_internal_service();
+++
+++ void add_timer(high_resolution_timer* t);
+++ void remove_timer(high_resolution_timer* t);
+++
+++ ip::tcp::endpoint bind_socket(ip::tcp::socket* socket, ip::tcp::endpoint ep
+++ , boost::system::error_code& ec);
+++ void unbind_socket(ip::tcp::socket* socket
+++ , ip::tcp::endpoint const& ep);
+++ void rebind_socket(asio::ip::tcp::socket* prev, asio::ip::tcp::socket* s, asio::ip::tcp::endpoint ep);
+++
+++ ip::udp::endpoint bind_udp_socket(ip::udp::socket* socket, ip::udp::endpoint ep
+++ , boost::system::error_code& ec);
+++ void unbind_udp_socket(ip::udp::socket* socket
+++ , ip::udp::endpoint const& ep);
+++ void rebind_udp_socket(asio::ip::udp::socket* socket, asio::ip::udp::endpoint ep);
+++
+++ std::shared_ptr<aux::channel> internal_connect(ip::tcp::socket* s
+++ , ip::tcp::endpoint const& target, boost::system::error_code& ec);
+++
+++ route find_udp_socket(asio::ip::udp::socket const& socket
+++ , ip::udp::endpoint const& ep);
+++
+++ route const& get_outgoing_route(ip::address ip) const
+++ { return m_outgoing_route.find(ip)->second; }
+++
+++ route const& get_incoming_route(ip::address ip) const
+++ { return m_incoming_route.find(ip)->second; }
+++
+++ int get_path_mtu(const asio::ip::address& source, const asio::ip::address& dest) const;
+++ std::vector<ip::address> const& get_ips() const { return m_ips; }
+++
+++ sim::simulation& sim() { return m_sim; }
+++
+++ using executor_type = io_executor;
+++ executor_type get_executor() { return executor_type(*this); }
+++
+++ private:
+++
+++ sim::simulation& m_sim;
+++ std::vector<ip::address> m_ips;
+++
+++ // these are determined by the configuration. They may include NATs and
+++ // DSL modems (queues)
+++ std::map<ip::address, route> m_outgoing_route;
+++ std::map<ip::address, route> m_incoming_route;
+++
+++ bool m_stopped = false;
+++ };
+++
+++ template <typename Handler, typename Allocator>
+++ void io_executor::dispatch(Handler handler, Allocator const& a) const
+++ { m_ctx->dispatch_impl(std::move(handler), a); }
+++
+++ template <typename Handler, typename Allocator>
+++ void io_executor::post(Handler handler, Allocator const& a) const
+++ { m_ctx->post_impl(std::move(handler), a); }
+++
+++ template <typename Handler, typename Allocator>
+++ void io_executor::defer(Handler handler, Allocator const& a) const
+++ { m_ctx->defer_impl(std::move(handler), a); }
+++
+++ template <typename Protocol>
+++ io_executor
+++ socket_base<Protocol>::get_executor()
+++ { return io_executor(m_io_service); }
+++
+++ template <typename Protocol>
+++ route socket_base<Protocol>::get_incoming_route()
+++ {
+++ route ret = m_io_service.get_incoming_route(m_bound_to.address());
+++ assert(m_forwarder);
+++ ret.append(std::static_pointer_cast<sim::sink>(m_forwarder));
+++ return ret;
+++ }
+++
+++ template <typename Protocol>
+++ route socket_base<Protocol>::get_outgoing_route()
+++ {
+++ return route(m_io_service.get_outgoing_route(m_bound_to.address()));
+++ }
+++
+++ } // asio
+++
+++ // user supplied configuration of the network to simulate
+++ struct SIMULATOR_DECL configuration
+++ {
+++ virtual ~configuration() {}
+++
+++ // build the network
+++ virtual void build(simulation& sim) = 0;
+++
+++ // return the hops on the network packets from src to dst need to traverse
+++ virtual route channel_route(asio::ip::address src
+++ , asio::ip::address dst) = 0;
+++
+++ // return the hops an incoming packet to ep need to traverse before
+++ // reaching the socket (for instance a NAT)
+++ virtual route incoming_route(asio::ip::address ip) = 0;
+++
+++ // return the hops an outgoing packet from ep need to traverse before
+++ // reaching the network (for instance a DSL modem)
+++ virtual route outgoing_route(asio::ip::address ip) = 0;
+++
+++ // return the path MTU between the two IP addresses
+++ // For TCP sockets, this will be called once when the connection is
+++ // established. For UDP sockets it's called for every burst of packets
+++ // that are sent
+++ virtual int path_mtu(asio::ip::address ip1, asio::ip::address ip2) = 0;
+++
+++ // called for every hostname lookup made by the client. ``reqyestor`` is
+++ // the node performing the lookup, ``hostname`` is the name being looked
+++ // up. Resolve the name into addresses and fill in ``result`` or set
+++ // ``ec`` if the hostname is not found or some other error occurs. The
+++ // return value is the latency of the lookup. The client's callback won't
+++ // be called until after waiting this long.
+++ virtual chrono::high_resolution_clock::duration hostname_lookup(
+++ asio::ip::address const& requestor
+++ , std::string hostname
+++ , std::vector<asio::ip::address>& result
+++ , boost::system::error_code& ec) = 0;
+++
+++ virtual void clear() = 0;
+++ };
+++
+++ struct SIMULATOR_DECL default_config : configuration
+++ {
+++ default_config() : m_sim(nullptr) {}
+++
+++ void build(simulation& sim) override;
+++ route channel_route(asio::ip::address src, asio::ip::address dst) override;
+++ route incoming_route(asio::ip::address ip) override;
+++ route outgoing_route(asio::ip::address ip) override;
+++ int path_mtu(asio::ip::address ip1, asio::ip::address ip2) override;
+++ chrono::high_resolution_clock::duration hostname_lookup(
+++ asio::ip::address const& requestor
+++ , std::string hostname
+++ , std::vector<asio::ip::address>& result
+++ , boost::system::error_code& ec) override;
+++
+++ void clear() override;
+++ protected:
+++ std::shared_ptr<queue> m_network;
+++ std::map<asio::ip::address, std::shared_ptr<queue>> m_incoming;
+++ std::map<asio::ip::address, std::shared_ptr<queue>> m_outgoing;
+++ simulation* m_sim;
+++ };
+++
+++ namespace aux
+++ {
+++ /* the channel can be in the following states:
+++ 1. handshake-1 - the initiating socket has sent SYN
+++ 2. handshake-2 - the accepting connection has sent SYN+ACK
+++ 3. handshake-3 - the initiating connection has received the SYN+ACK and
+++ considers the connection open, but the 3rd handshake
+++ message is still in flight.
+++ 4. connected - the accepting side has received the 3rd handshake
+++ packet and considers it open
+++
+++ Whenever a connection attempt is made to a listening socket, as long as
+++ there is still space in the incoming socket queue, the accepting side
+++ will always respond immediately and complete the handshake, then wait
+++ until the user calls async_accept (which in this case would complete
+++ immediately).
+++ */
+++ struct SIMULATOR_DECL channel
+++ {
+++ channel() {}
+++ // index 0 is the incoming route to the socket that initiated the connection.
+++ // index 1 may be empty while the connection is half-open
+++ route hops[2];
+++
+++ // the actual endpoint of each end of the channel
+++ asio::ip::tcp::endpoint ep[2];
+++
+++ // observable endpoint of each side of the channel. This is not how you
+++ // see yourself, just the other end
+++ asio::ip::tcp::endpoint visible_ep[2];
+++
+++ // the number of bytes sent from respective direction
+++ // this is used to simulate the TCP sequence number, so it deliberately
+++ // is meant to wrap at 32 bits
+++ std::uint32_t bytes_sent[2];
+++
+++ int remote_idx(asio::ip::tcp::endpoint const& self) const;
+++ int self_idx(asio::ip::tcp::endpoint const& self) const;
+++ };
+++
+++ } // aux
+++
+++ void SIMULATOR_DECL dump_network_graph(simulation const& s, const std::string& filename);
+++}
+++
+++#ifdef _MSC_VER
+++#pragma warning(pop)
+++#endif
+++
+++#endif // SIMULATOR_HPP_INCLUDED
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/sink.hpp
++@@ -0,0 +1,47 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef SINK_HPP_INCLUDED
+++#define SINK_HPP_INCLUDED
+++
+++#include "simulator/config.hpp"
+++#include <string>
+++
+++namespace sim {
+++
+++namespace aux {
+++ struct packet;
+++}
+++
+++ // this is an interface for somthing that can accept incoming packets,
+++ // such as queues, sockets, NATs and TCP congestion windows
+++ struct SIMULATOR_DECL sink
+++ {
+++ virtual void incoming_packet(aux::packet p) = 0;
+++
+++ // used for visualization
+++ virtual std::string label() const = 0;
+++
+++ virtual std::string attributes() const { return "shape=box"; }
+++ virtual ~sink() = default;
+++ };
+++
+++} // sim
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/sink_forwarder.hpp
++@@ -0,0 +1,43 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef SINK_FORWARDER_HPP_INCLUDED
+++#define SINK_FORWARDER_HPP_INCLUDED
+++
+++#include "simulator/config.hpp"
+++#include "simulator/sink.hpp"
+++
+++namespace sim { namespace aux {
+++
+++ struct packet;
+++
+++ struct SIMULATOR_DECL sink_forwarder final : sink
+++ {
+++ sink_forwarder(sink* dst);
+++ void incoming_packet(packet p) override;
+++ std::string label() const override;
+++ void reset(sink* s = nullptr);
+++
+++ private:
+++ sink* m_dst;
+++ };
+++
+++}} // sim
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/socks_server.hpp
++@@ -0,0 +1,202 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef SOCKS_SERVER_HPP_INCLUDED
+++#define SOCKS_SERVER_HPP_INCLUDED
+++
+++#include "simulator/simulator.hpp"
+++
+++#ifdef __GNUC__
+++#pragma GCC diagnostic push
+++#if __GNUC__ >= 9
+++#pragma GCC diagnostic ignored "-Wparentheses"
+++#endif
+++#endif
+++
+++#include <boost/bimap.hpp>
+++
+++#ifdef __GNUC__
+++#pragma GCC diagnostic pop
+++#endif
+++
+++#ifdef _MSC_VER
+++#pragma warning(push)
+++// warning C4251: X: class Y needs to have dll-interface to be used by clients of struct
+++#pragma warning( disable : 4251)
+++#endif
+++
+++namespace sim
+++{
+++
+++enum socks_flag
+++{
+++ // when this flag is set, the proxy will close the client connection
+++ // immediately after sending the response to a UDP ASSOCIATE command
+++ disconnect_udp_associate = 1,
+++
+++ // when this flag is set, the reponse to UDP ASSOCIATE will contain an empty
+++ // hostname, rather than the relay IP address
+++ udp_associate_respond_empty_hostname = 2
+++};
+++
+++struct SIMULATOR_DECL socks_connection : std::enable_shared_from_this<socks_connection>
+++{
+++ socks_connection(asio::io_context& ios, int version, std::array<int, 3>& cmd_counts
+++ , std::uint32_t flags, int& bind_port);
+++
+++ asio::ip::tcp::socket& socket() { return m_client_connection; }
+++
+++ void start();
+++
+++private:
+++
+++ void on_handshake1(boost::system::error_code const& ec, size_t bytes_transferred);
+++ void on_handshake2(boost::system::error_code const& ec, size_t bytes_transferred);
+++ void on_handshake3(boost::system::error_code const& ec, size_t bytes_transferred);
+++ void on_request1(boost::system::error_code const& ec, size_t bytes_transferred);
+++ void on_request2(boost::system::error_code const& ec, size_t bytes_transferred);
+++
+++ void on_write(boost::system::error_code const& ec, size_t bytes_transferred
+++ , bool close);
+++ void close_connection();
+++
+++ int format_response(asio::ip::address const& addr, int port, int response);
+++ int format_hostname_response(char const* hostname, int port, int response);
+++
+++ void on_connected(boost::system::error_code const& ec);
+++ void on_request_domain_name(boost::system::error_code const& ec, size_t bytes_transferred);
+++ void on_request_domain_lookup(boost::system::error_code const& ec
+++ , const asio::ip::tcp::resolver::results_type ips);
+++
+++ void open_forward_connection(asio::ip::tcp::endpoint const& target);
+++ void bind_connection(asio::ip::tcp::endpoint const& target);
+++ void start_accept(boost::system::error_code const& ec);
+++
+++ void udp_associate(asio::ip::tcp::endpoint const& target);
+++ void on_read_udp(boost::system::error_code const& ec, std::size_t bytes_transferred);
+++ void wait_for_eof(boost::system::error_code const& ec, std::size_t bytes_transferred);
+++
+++ void on_server_receive(boost::system::error_code const& ec
+++ , std::size_t bytes_transferred);
+++ void on_server_forward(boost::system::error_code const& ec
+++ , size_t bytes_transferred);
+++
+++ void on_client_receive(boost::system::error_code const& ec
+++ , std::size_t bytes_transferred);
+++ void on_client_forward(boost::system::error_code const& ec
+++ , size_t bytes_transferred);
+++
+++ char const* command() const;
+++
+++ int& m_bind_port;
+++
+++ asio::io_context& m_ios;
+++
+++ asio::ip::udp::resolver m_udp_resolver;
+++
+++ asio::ip::tcp::resolver m_resolver;
+++
+++ boost::bimap<asio::ip::address, std::string> m_name_mapping;
+++
+++ // this is the SOCKS client connection, i.e. the client connecting to us and
+++ // being forwarded
+++ asio::ip::tcp::socket m_client_connection;
+++
+++ // this is the connection to the server the socks client is being forwarded
+++ // to
+++ asio::ip::tcp::socket m_server_connection;
+++ asio::ip::tcp::acceptor m_bind_socket;
+++
+++ asio::ip::udp::socket m_udp_associate;
+++ asio::ip::udp::endpoint m_udp_associate_ep;
+++ asio::ip::udp::endpoint m_udp_from;
+++
+++ std::array<char, 1500> m_udp_buffer;
+++
+++ // receive buffer for data going out, i.e. client -> proxy (us) -> server
+++ char m_out_buffer[65536];
+++ // buffer size
+++ int m_num_out_bytes;
+++
+++ // receive buffer for data coming in, i.e. server -> proxy (us) -> client
+++ char m_in_buffer[65536];
+++ // buffer size
+++ int m_num_in_bytes;
+++
+++ // set to true when shutting down
+++ bool m_close = false;
+++
+++ // the SOCKS protocol version (4 or 5)
+++ const int m_version;
+++
+++ int m_command;
+++
+++ std::array<int, 3>& m_cmd_counts;
+++
+++ std::uint32_t const m_flags;
+++};
+++
+++// This is a very simple socks4 and 5 server that only supports a single
+++// concurrent connection
+++struct SIMULATOR_DECL socks_server
+++{
+++ socks_server(asio::io_context& ios, unsigned short listen_port
+++ , int version = 5, std::uint32_t flags = 0);
+++
+++ void stop();
+++
+++ void bind_start_port(int const port) { m_bind_port = port; }
+++
+++ // return the number of CONNECT, BIND and UDP_ASSOCIATE commands the proxy
+++ // has received
+++ std::array<int, 3> cmd_counts() const
+++ { return m_cmd_counts; }
+++
+++private:
+++
+++ void on_accept(boost::system::error_code const& ec);
+++
+++ asio::io_context& m_ios;
+++
+++ asio::ip::tcp::acceptor m_listen_socket;
+++
+++ std::shared_ptr<socks_connection> m_conn;
+++
+++ asio::ip::tcp::endpoint m_ep;
+++
+++ int m_bind_port = 2048;
+++
+++ // set to true when shutting down
+++ bool m_close = false;
+++
+++ // the SOCKS protocol version (4 or 5)
+++ const int m_version;
+++
+++ std::array<int, 3> m_cmd_counts;
+++
+++ std::uint32_t const m_flags;
+++};
+++
+++}
+++
+++#ifdef _MSC_VER
+++#pragma warning(pop)
+++#endif
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/ssl.hpp
++@@ -0,0 +1,44 @@
+++/*
+++
+++Copyright (c) 2026, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef SIMULATOR_SSL_HPP_INCLUDED
+++#define SIMULATOR_SSL_HPP_INCLUDED
+++
+++#include "simulator/simulator.hpp"
+++
+++#include "simulator/push_warnings.hpp"
+++#include <boost/asio/ssl.hpp>
+++#include "simulator/pop_warnings.hpp"
+++
+++namespace sim {
+++namespace asio {
+++
+++namespace ssl
+++{
+++ using boost::asio::ssl::context;
+++ using boost::asio::ssl::stream_base;
+++ using boost::asio::ssl::verify_context;
+++
+++ template <typename Stream>
+++ using stream = boost::asio::ssl::stream<Stream>;
+++} // ssl
+++
+++} // asio
+++} // sim
+++
+++#endif
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/include/simulator/utils.hpp
++@@ -0,0 +1,47 @@
+++/*
+++
+++Copyright (c) 2016, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#ifndef UTILS_HPP_INCLUDED
+++#define UTILS_HPP_INCLUDED
+++
+++#include "simulator/simulator.hpp"
+++
+++namespace sim
+++{
+++
+++// shortcut for creating a timer with a timeout and action
+++struct timer
+++{
+++ timer(simulation& sim, chrono::high_resolution_clock::duration timeout
+++ , aux::function<void(boost::system::error_code const&)>&& f)
+++ : m_ios(sim, asio::ip::address_v4())
+++ , m_timer(m_ios)
+++ {
+++ m_timer.expires_after(timeout);
+++ m_timer.async_wait(std::move(f));
+++ }
+++
+++private:
+++ sim::asio::io_context m_ios;
+++ sim::asio::high_resolution_timer m_timer;
+++};
+++
+++} // sim
+++
+++#endif
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/acceptor.cpp
++@@ -0,0 +1,379 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include "simulator/packet.hpp"
+++
+++#include <functional>
+++#include <boost/beast/core/bind_handler.hpp>
+++
+++#include <cinttypes>
+++
+++using boost::beast::bind_handler;
+++
+++typedef sim::chrono::high_resolution_clock::time_point time_point;
+++typedef sim::chrono::high_resolution_clock::duration duration;
+++
+++namespace sim {
+++namespace asio {
+++namespace ip {
+++
+++ tcp::acceptor::acceptor(io_context& ios)
+++ : socket(ios)
+++ , m_queue_size_limit(-1)
+++ {}
+++
+++ tcp::acceptor::acceptor(acceptor&&) = default;
+++
+++ tcp::acceptor::~acceptor()
+++ {
+++ boost::system::error_code ec;
+++ close(ec);
+++ }
+++
+++ void tcp::acceptor::listen(int qs)
+++ {
+++ boost::system::error_code ec;
+++ listen(qs, ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ }
+++
+++ void tcp::acceptor::listen(int qs, boost::system::error_code& ec)
+++ {
+++ if (qs == -1) qs = 20;
+++
+++ if (!m_open)
+++ {
+++ ec = error::bad_descriptor;
+++ return;
+++ }
+++ if (m_bound_to == ip::tcp::endpoint())
+++ {
+++ ec = error::invalid_argument;
+++ return;
+++ }
+++
+++ m_queue_size_limit = qs;
+++ ec.clear();
+++ }
+++
+++ void tcp::acceptor::close(boost::system::error_code& ec)
+++ {
+++ m_queue_size_limit = -1;
+++ cancel(ec);
+++ socket::close(ec);
+++ }
+++
+++ void tcp::acceptor::close()
+++ {
+++ if (m_accept_handler)
+++ {
+++ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
+++ , boost::system::error_code(error::operation_aborted)));
+++ }
+++ if (m_accept_handler2)
+++ {
+++ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
+++ h(boost::system::error_code(error::operation_aborted)
+++ , ip::tcp::socket(m_io_service));
+++ });
+++ }
+++ }
+++
+++ void tcp::acceptor::cancel(boost::system::error_code& ec)
+++ {
+++ ec.clear();
+++ if (m_accept_handler)
+++ {
+++ try
+++ {
+++ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
+++ , boost::system::error_code(error::operation_aborted)));
+++ }
+++ catch (std::bad_alloc const&)
+++ {
+++ ec = error::no_memory;
+++ }
+++ catch (std::exception const&)
+++ {
+++ ec = error::no_memory;
+++ }
+++ }
+++ if (m_accept_handler2)
+++ {
+++ try
+++ {
+++ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
+++ h(boost::system::error_code(error::operation_aborted)
+++ , ip::tcp::socket(m_io_service));
+++ });
+++ }
+++ catch (std::bad_alloc const&)
+++ {
+++ ec = error::no_memory;
+++ }
+++ catch (std::exception const&)
+++ {
+++ ec = error::no_memory;
+++ }
+++ }
+++ }
+++
+++ void tcp::acceptor::cancel()
+++ {
+++ boost::system::error_code ec;
+++ cancel(ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ }
+++
+++ void tcp::acceptor::async_accept(ip::tcp::socket& peer
+++ , aux::function<void(boost::system::error_code const&)> h)
+++ {
+++ // TODO: assert that the io_context we use is the same as the one peer use
+++ if (peer.is_open())
+++ {
+++ boost::system::error_code ec;
+++ peer.close(ec);
+++ }
+++
+++ if (m_accept_handler)
+++ {
+++ m_accept_into = nullptr;
+++ m_remote_endpoint = nullptr;
+++ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
+++ , boost::system::error_code(error::operation_aborted)));
+++ }
+++ if (m_accept_handler2)
+++ {
+++ m_accept_into = nullptr;
+++ m_remote_endpoint = nullptr;
+++ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
+++ h(boost::system::error_code(error::operation_aborted)
+++ , ip::tcp::socket(m_io_service));
+++ });
+++ }
+++ m_accept_handler = std::move(h);
+++ m_accept_into = &peer;
+++ m_remote_endpoint = nullptr;
+++
+++ check_accept_queue();
+++ }
+++
+++ void tcp::acceptor::async_accept(ip::tcp::socket& peer
+++ , ip::tcp::endpoint& peer_endpoint
+++ , aux::function<void(boost::system::error_code const&)> h)
+++ {
+++ if (peer.is_open())
+++ {
+++ boost::system::error_code ec;
+++ peer.close(ec);
+++ }
+++
+++ if (m_accept_handler)
+++ {
+++ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
+++ , boost::system::error_code(error::operation_aborted)));
+++ }
+++ if (m_accept_handler2)
+++ {
+++ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
+++ h(boost::system::error_code(error::operation_aborted)
+++ , ip::tcp::socket(m_io_service));
+++ });
+++ }
+++ m_accept_handler = std::move(h);
+++ m_accept_into = &peer;
+++ m_remote_endpoint = &peer_endpoint;
+++
+++ check_accept_queue();
+++ }
+++
+++ void tcp::acceptor::async_accept(aux::function<void(boost::system::error_code const&, ip::tcp::socket peer)> h)
+++ {
+++ m_remote_endpoint = nullptr;
+++ if (m_accept_handler)
+++ {
+++ m_accept_into = nullptr;
+++ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
+++ , boost::system::error_code(error::operation_aborted)));
+++ }
+++ if (m_accept_handler2)
+++ {
+++ m_accept_into = nullptr;
+++ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
+++ h(boost::system::error_code(error::operation_aborted)
+++ , ip::tcp::socket(m_io_service));
+++ });
+++ }
+++ m_new_socket.emplace(m_io_service);
+++ m_accept_handler2 = std::move(h);
+++ m_accept_into = &*m_new_socket;
+++
+++ check_accept_queue();
+++ }
+++
+++ void tcp::acceptor::do_check_accept_queue(boost::system::error_code const& ec)
+++ {
+++ if (ec) return;
+++ check_accept_queue();
+++ }
+++
+++ void tcp::acceptor::incoming_packet(aux::packet p)
+++ {
+++ switch (p.type)
+++ {
+++ case aux::packet::type_t::syn:
+++ m_incoming_conns.push_back(p.channel);
+++ check_accept_queue();
+++ return;
+++ case aux::packet::type_t::error:
+++ assert(false); // something is not wired up correctly
+++ if (m_accept_handler)
+++ {
+++ m_accept_into = nullptr;
+++ m_remote_endpoint = nullptr;
+++ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
+++ , boost::system::error_code(error::operation_aborted)));
+++ }
+++ if (m_accept_handler2)
+++ {
+++ m_accept_into = nullptr;
+++ m_remote_endpoint = nullptr;
+++ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
+++ h(boost::system::error_code(error::operation_aborted)
+++ , ip::tcp::socket(m_io_service));
+++ });
+++ }
+++ return;
+++ default:
+++ // if this happens, it implies that an incoming connection sent
+++ // payload before receiving a syn_ack. Alternatively that the
+++ // acceptor sent the syn_ack but still left the last-hop in the
+++ // incoming route to point to this socket, instead of the
+++ // accepted-into socket
+++ assert(false);
+++ return;
+++ }
+++ }
+++
+++ void tcp::acceptor::check_accept_queue()
+++ {
+++ if (!is_open())
+++ {
+++ // if the acceptor socket is closed. Any potential socket in the queue
+++ // should be closed too.
+++ for (auto const& incoming : m_incoming_conns)
+++ {
+++ aux::packet p;
+++ p.from = asio::ip::udp::endpoint(
+++ m_bound_to.address(), m_bound_to.port());
+++ p.type = aux::packet::type_t::error;
+++ p.ec = boost::system::error_code(error::connection_reset);
+++ p.overhead = 28;
+++ p.hops = incoming->hops[0];
+++
+++ forward_packet(std::move(p));
+++ }
+++ m_incoming_conns.clear();
+++
+++ if (m_accept_handler)
+++ {
+++ m_accept_into = nullptr;
+++ m_remote_endpoint = nullptr;
+++ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr)
+++ , boost::system::error_code(error::operation_aborted)));
+++ }
+++ if (m_accept_handler2)
+++ {
+++ m_accept_into = nullptr;
+++ m_remote_endpoint = nullptr;
+++ post(m_io_service, [&, h = std::exchange(m_accept_handler2, nullptr)] () mutable {
+++ h(boost::system::error_code(error::operation_aborted)
+++ , ip::tcp::socket(m_io_service));
+++ });
+++ }
+++ }
+++
+++ // if the user is not waiting for an incoming connection, there's no point
+++ // in checking the queue
+++ if (!m_accept_handler && !m_accept_handler2) return;
+++
+++ if (m_incoming_conns.empty()) return;
+++
+++ std::shared_ptr<aux::channel> c = std::move(m_incoming_conns.front());
+++ m_incoming_conns.erase(m_incoming_conns.begin());
+++
+++ // this was initiated at least one 3-way handshake ago.
+++ // we can pick it up and consider it connected
+++ if (m_remote_endpoint) *m_remote_endpoint = c->ep[0];
+++ m_remote_endpoint = nullptr;
+++
+++ boost::system::error_code ec;
+++ // if the acceptor socket is closed. Any potential socket in the queue
+++ m_accept_into->internal_connect(m_bound_to, c, ec);
+++
+++ // notify the other end
+++ aux::packet p;
+++ p.from = asio::ip::udp::endpoint(m_bound_to.address(), m_bound_to.port());
+++ if (ec)
+++ {
+++ c->hops[1] = route();
+++ p.type = aux::packet::type_t::error;
+++ p.ec = ec;
+++ }
+++ else
+++ {
+++ // TODO: extend pcap logging to include SYN+ACK packets
+++ p.type = aux::packet::type_t::syn_ack;
+++ }
+++ p.channel = c;
+++ p.overhead = 28;
+++ p.hops = p.channel->hops[0];
+++
+++ forward_packet(std::move(p));
+++
+++ try
+++ {
+++ if (m_accept_handler)
+++ {
+++ post(m_io_service, bind_handler(std::exchange(m_accept_handler, nullptr), ec));
+++ }
+++ else if (m_accept_handler2)
+++ {
+++ post(m_io_service, bind_handler(std::exchange(m_accept_handler2, nullptr)
+++ , ec, std::move(*m_accept_into)));
+++ }
+++ }
+++ catch (...)
+++ {
+++ m_new_socket.reset();
+++ m_accept_into = nullptr;
+++ throw;
+++ }
+++ m_new_socket.reset();
+++ m_accept_into = nullptr;
+++ }
+++
+++ bool tcp::acceptor::internal_is_listening()
+++ {
+++ return m_queue_size_limit > 0;
+++ }
+++}
+++}
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/default_config.cpp
++@@ -0,0 +1,106 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include "simulator/queue.hpp"
+++#include <memory>
+++
+++typedef sim::chrono::high_resolution_clock::time_point time_point;
+++typedef sim::chrono::high_resolution_clock::duration duration;
+++using sim::asio::ip::address_v4;
+++using sim::asio::ip::address_v6;
+++using sim::asio::ip::address;
+++using sim::chrono::milliseconds;
+++using sim::chrono::duration_cast;
+++
+++namespace sim {
+++
+++ void default_config::build(simulation& sim)
+++ {
+++ // 0 bandwidth and 0 queue means infinite. The network itself only adds
+++ // 50 ms latency
+++ m_network = std::make_shared<queue>(std::ref(sim.get_io_context())
+++ , 0, duration_cast<duration>(milliseconds(30)), 0, "network");
+++ m_sim = ∼
+++ }
+++
+++ void default_config::clear()
+++ {
+++ m_network.reset();
+++ m_outgoing.clear();
+++ m_incoming.clear();
+++ }
+++
+++ route default_config::channel_route(
+++ asio::ip::address /* src */
+++ , asio::ip::address /* dst */)
+++ {
+++ return route().append(m_network);
+++ }
+++
+++ route default_config::incoming_route(asio::ip::address ip)
+++ {
+++ // incoming download rate is 800kB/s with a 200 kB queue
+++ // and 1 ms forwarding delay
+++ auto it = m_incoming.find(ip);
+++ if (it != m_incoming.end()) return route().append(it->second);
+++ it = m_incoming.insert(it, std::make_pair(ip, std::make_shared<queue>(
+++ std::ref(m_sim->get_io_context()), 800 * 1000
+++ , duration_cast<duration>(milliseconds(1)), 200 * 1000, "DSL modem in")));
+++ return route().append(it->second);
+++ }
+++
+++ int default_config::path_mtu(
+++ asio::ip::address /* ip1 */
+++ , asio::ip::address /* ip2 */)
+++ {
+++ return 1475;
+++ }
+++
+++ // return the hops an outgoing packet from ep need to traverse before
+++ // reaching the network (for instance a DSL modem)
+++ route default_config::outgoing_route(asio::ip::address ip)
+++ {
+++ // outgoing upload rate is 200kB/s with a 200 kB queue
+++ // and 1 ms forwarding delay
+++ auto it = m_outgoing.find(ip);
+++ if (it != m_outgoing.end()) return route().append(it->second);
+++ it = m_outgoing.insert(it, std::make_pair(ip, std::make_shared<queue>(
+++ std::ref(m_sim->get_io_context()), 200 * 1000
+++ , duration_cast<duration>(milliseconds(1)), 200 * 1000, "DSL modem out")));
+++ return route().append(it->second);
+++ }
+++
+++ duration default_config::hostname_lookup(
+++ asio::ip::address const& /* requestor */
+++ , std::string hostname
+++ , std::vector<asio::ip::address>& result
+++ , boost::system::error_code& ec)
+++ {
+++ if (hostname == "localhost")
+++ {
+++ result = { asio::ip::make_address_v6("::1")
+++ , asio::ip::make_address_v4("127.0.0.1") };
+++ return duration_cast<duration>(chrono::microseconds(1));
+++ }
+++
+++ ec = boost::system::error_code(asio::error::host_not_found);
+++ return duration_cast<duration>(chrono::milliseconds(100));
+++ }
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/high_resolution_clock.cpp
++@@ -0,0 +1,51 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++
+++#include <functional>
+++
+++#include "simulator/push_warnings.hpp"
+++#include <boost/system/error_code.hpp>
+++#include "simulator/pop_warnings.hpp"
+++
+++namespace sim { namespace chrono {
+++ namespace {
+++
+++ // this is the global simulation timer
+++ high_resolution_clock::time_point g_simulation_time;
+++ }
+++
+++ high_resolution_clock::time_point high_resolution_clock::now()
+++ {
+++ return g_simulation_time;
+++ }
+++
+++ void high_resolution_clock::fast_forward(high_resolution_clock::duration d)
+++ {
+++ g_simulation_time += d;
+++ }
+++
+++ void reset_clock()
+++ {
+++ g_simulation_time = high_resolution_clock::time_point{};
+++ }
+++
+++} // chrono
+++} // sim
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/high_resolution_timer.cpp
++@@ -0,0 +1,141 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include "simulator/handler_allocator.hpp"
+++
+++#include <functional>
+++#include <boost/system/error_code.hpp>
+++
+++namespace sim
+++{
+++
+++ namespace asio {
+++
+++ high_resolution_timer::high_resolution_timer(io_context& ioc)
+++ : m_expiration_time(time_type())
+++ , m_io_service(&ioc)
+++ , m_expired(true)
+++ {
+++ }
+++
+++ high_resolution_timer::high_resolution_timer(io_context& ioc,
+++ const time_type& expiry_time)
+++ : m_expiration_time(time_type())
+++ , m_io_service(&ioc)
+++ , m_expired(true)
+++ {
+++ expires_at(expiry_time);
+++ }
+++
+++ high_resolution_timer::high_resolution_timer(io_context& ioc,
+++ const duration_type& expiry_time)
+++ : m_expiration_time(time_type())
+++ , m_io_service(&ioc)
+++ , m_expired(true)
+++ {
+++ expires_after(expiry_time);
+++ }
+++
+++ high_resolution_timer::~high_resolution_timer()
+++ {
+++ cancel();
+++ }
+++
+++ std::size_t high_resolution_timer::cancel()
+++ {
+++ if (m_expired) return 0;
+++ m_expired = true;
+++ m_io_service->remove_timer(this);
+++ if (!m_handler) return 0;
+++ fire(boost::asio::error::operation_aborted);
+++ return 1;
+++ }
+++
+++ std::size_t high_resolution_timer::cancel_one()
+++ {
+++ // TODO: support multiple handlers
+++ return cancel();
+++ }
+++
+++ high_resolution_timer::time_type high_resolution_timer::expiry() const
+++ { return m_expiration_time; }
+++
+++ std::size_t high_resolution_timer::expires_at(high_resolution_timer::time_type const& expiry_time)
+++ {
+++ std::size_t ret = cancel();
+++ m_expiration_time = expiry_time;
+++ m_expired = false;
+++ m_io_service->add_timer(this);
+++ return ret;
+++ }
+++
+++ std::size_t high_resolution_timer::expires_after(const duration_type& expiry_time)
+++ {
+++ std::size_t ret = cancel();
+++ m_expiration_time = chrono::high_resolution_clock::now() + expiry_time;
+++ m_expired = false;
+++ m_io_service->add_timer(this);
+++ return ret;
+++ }
+++
+++ void high_resolution_timer::wait()
+++ {
+++ assert(false && "can't use synchcronous calls in simulator");
+++ boost::system::error_code ec;
+++ wait(ec);
+++ }
+++
+++ void high_resolution_timer::wait(boost::system::error_code&)
+++ {
+++ assert(false && "can't use synchcronous calls in simulator");
+++ time_type now = chrono::high_resolution_clock::now();
+++ if (now >= m_expiration_time) return;
+++ chrono::high_resolution_clock::fast_forward(m_expiration_time - now);
+++ }
+++
+++ void high_resolution_timer::async_wait(aux::function<void(boost::system::error_code const&)> handler)
+++ {
+++ // TODO: support multiple handlers
+++ assert(!m_handler);
+++ m_handler = std::move(handler);
+++ if (m_expired)
+++ {
+++ fire(boost::system::error_code());
+++ return;
+++ }
+++ }
+++
+++ void high_resolution_timer::fire(boost::system::error_code ec)
+++ {
+++ m_expired = true;
+++ if (!m_handler) return;
+++ auto h = std::move(m_handler);
+++ m_handler = nullptr;
+++ post(*m_io_service, make_malloc(std::bind(std::move(h), ec)));
+++ }
+++
+++ high_resolution_timer::executor_type high_resolution_timer::get_executor()
+++ {
+++ return (*m_io_service).get_executor();
+++ }
+++
+++ } // asio
+++
+++} // sim
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/http_proxy.cpp
++@@ -0,0 +1,362 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include "simulator/http_proxy.hpp"
+++#include "simulator/http_server.hpp" // for helper functions
+++
+++#include <functional>
+++#include <cstdio> // for printf
+++
+++using namespace sim::asio;
+++using namespace sim::asio::ip;
+++using namespace std::placeholders;
+++
+++using boost::system::error_code;
+++
+++namespace sim
+++{
+++ using namespace aux;
+++
+++ http_proxy::http_proxy(io_context& ios, unsigned short const listen_port)
+++ : m_resolver(ios)
+++ , m_listen_socket(ios)
+++ , m_client_connection(ios)
+++ , m_server_connection(ios)
+++ , m_writing_to_server(false)
+++ , m_num_client_in_bytes(0)
+++ , m_num_server_out_bytes(0)
+++ , m_num_in_bytes(0)
+++ , m_close(false)
+++ {
+++ address local_ip = ios.get_ips().front();
+++ if (local_ip.is_v4())
+++ {
+++ m_listen_socket.open(tcp::v4());
+++ m_listen_socket.bind(tcp::endpoint(address_v4::any(), listen_port));
+++ }
+++ else
+++ {
+++ m_listen_socket.open(tcp::v6());
+++ m_listen_socket.bind(tcp::endpoint(address_v6::any(), listen_port));
+++ }
+++ m_listen_socket.listen();
+++
+++ m_listen_socket.async_accept(m_client_connection, m_ep
+++ , std::bind(&http_proxy::on_accept, this, _1));
+++ }
+++
+++ void http_proxy::on_accept(error_code const& ec)
+++ {
+++ if (ec == asio::error::operation_aborted)
+++ return;
+++
+++ if (ec)
+++ {
+++ std::printf("http_proxy::on_accept: (%d) %s\n"
+++ , ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++ std::printf("http_proxy accepted connection from: %s : %d\n",
+++ m_ep.address().to_string().c_str(), m_ep.port());
+++
+++ // read http request
+++ m_client_connection.async_read_some(asio::buffer(
+++ &m_client_in_buffer[0], sizeof(m_client_in_buffer))
+++ , std::bind(&http_proxy::on_read_request, this, _1, _2));
+++ }
+++
+++ void http_proxy::on_read_request(error_code const& ec, size_t bytes_transferred) try
+++ {
+++ if (ec)
+++ {
+++ std::printf("http_proxy::on_read_request: (%d) %s\n"
+++ , ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++ m_num_client_in_bytes += int(bytes_transferred);
+++
+++ // scan for end of HTTP request
+++ int req_len = find_request_len(m_client_in_buffer, m_num_client_in_bytes);
+++ while (req_len >= 0)
+++ {
+++ // parse request from [0, eor), connect to target server and forward
+++ // the request.
+++ http_request const req = parse_request(m_client_in_buffer, req_len);
+++ forward_request(req);
+++
+++ // pop this request from the receive buffer
+++ memmove(m_client_in_buffer, m_client_in_buffer + req_len
+++ , m_num_client_in_bytes - req_len);
+++ m_num_client_in_bytes -= req_len;
+++
+++ // is there another request in the buffer?
+++ req_len = find_request_len(m_client_in_buffer, m_num_client_in_bytes);
+++ }
+++
+++ // read more from the client
+++ m_client_connection.async_read_some(asio::buffer(
+++ &m_client_in_buffer[m_num_client_in_bytes]
+++ , sizeof(m_client_in_buffer) - m_num_client_in_bytes)
+++ , std::bind(&http_proxy::on_read_request, this, _1, _2));
+++ }
+++ catch (std::runtime_error& e)
+++ {
+++ std::printf("http_proxy::on_read_request() failed: %s\n"
+++ , e.what());
+++ close_connection();
+++ }
+++
+++ void http_proxy::forward_request(http_request const& req)
+++ {
+++ std::string out_request;
+++ out_request = req.method;
+++ out_request += ' ';
+++ if (req.req.compare(0, 7, "http://") != 0)
+++ {
+++ std::printf("http_proxy::forward_request: expected full URL in request, got: %s\n"
+++ , req.req.c_str());
+++ throw std::runtime_error("invalid request");
+++ }
+++
+++ std::string::size_type const path_start = req.req.find_first_of('/', 7);
+++ if (path_start == std::string::npos) out_request += '/';
+++ else out_request.append(req.req, path_start, std::string::npos);
+++ out_request += " HTTP/1.1\r\n";
+++
+++ std::string::size_type const host_end = req.req.substr(0, path_start).find_last_of(':');
+++
+++ std::string host = req.req.substr(7, (host_end != std::string::npos && host_end > 7)
+++ ? host_end - 7 : path_start - 7);
+++
+++ // if the hostname is an IPv6 address, strip the brackets around it to
+++ // make it parse correctly
+++ if (host.size() >= 2 && host.front() == '[' && host.back() == ']')
+++ host = host.substr(1, host.size() - 2);
+++
+++ int const port = host_end == std::string::npos || host_end <= 7 ? 80
+++ : atoi(req.req.substr(host_end + 1, path_start).c_str());
+++ assert(port >= 0 && port < 0xffff);
+++
+++ bool found_host = false;
+++ for (auto const& h : req.headers)
+++ {
+++ if (h.first == "host") found_host = true;
+++
+++ out_request += h.first;
+++ out_request += ": ";
+++ out_request += h.second;
+++ out_request += "\r\n";
+++ }
+++ if (!found_host)
+++ {
+++ out_request += "host: ";
+++ out_request += host;
+++ out_request += "\r\n";
+++ }
+++ out_request += "\r\n";
+++
+++ if (m_num_server_out_bytes + out_request.size() > sizeof(m_server_out_buffer))
+++ {
+++ std::printf("http_proxy: Too many queued server requests: %d bytes\n"
+++ , int(m_num_server_out_bytes + out_request.size()));
+++ throw std::runtime_error("pipeline too deep");
+++ }
+++ memmove(&m_server_out_buffer[m_num_server_out_bytes]
+++ , out_request.data(), out_request.size());
+++ m_num_server_out_bytes += int(out_request.size());
+++
+++ if (!m_server_connection.is_open())
+++ {
+++ boost::system::error_code err;
+++ tcp::endpoint target(make_address(host.c_str(), err)
+++ , static_cast<unsigned short>(port));
+++ if (err)
+++ {
+++ char port_str[10];
+++ std::snprintf(port_str, sizeof(port_str), "%d", port);
+++ m_resolver.async_resolve(host, port_str
+++ , std::bind(&http_proxy::on_domain_lookup, this, _1, _2));
+++ return;
+++ }
+++ open_forward_connection(target);
+++ return;
+++ }
+++
+++ // TODO: make sure we're connecting/connected to the same (host, port)
+++ // that this request is for. Don't support multiple servers
+++
+++ write_server_send_buffer();
+++ }
+++
+++ void http_proxy::on_domain_lookup(boost::system::error_code const& ec
+++ , const asio::ip::tcp::resolver::results_type ips)
+++ {
+++ if (ec || ips.empty())
+++ {
+++ if (ec)
+++ {
+++ std::printf("http_proxy::on_domain_lookup: (%d) %s\n"
+++ , ec.value(), ec.message().c_str());
+++ }
+++ else
+++ {
+++ std::printf("http_proxy::on_request_domain_lookup: empty response\n");
+++ }
+++ error(503, "Resource Temporarily Unavailable");
+++ return;
+++ }
+++ open_forward_connection(ips.front().endpoint());
+++ }
+++
+++ void http_proxy::open_forward_connection(const asio::ip::tcp::endpoint& target)
+++ {
+++ m_server_connection.open(target.protocol());
+++
+++ std::printf("http_proxy: async_connect: %s:%d\n"
+++ , target.address().to_string().c_str(), target.port());
+++ m_server_connection.async_connect(target
+++ , std::bind(&http_proxy::on_connected, this, _1));
+++ }
+++
+++ void http_proxy::error(int code, char const* message)
+++ {
+++ std::string send_buffer = send_response(code, message);
+++ memcpy(m_in_buffer, send_buffer.data(), send_buffer.size());
+++ asio::async_write(m_client_connection, asio::buffer(
+++ &m_in_buffer[0], send_buffer.size())
+++ , std::bind(&http_proxy::close_connection, this));
+++ }
+++
+++ void http_proxy::on_connected(boost::system::error_code const& ec)
+++ {
+++ if (ec)
+++ {
+++ std::printf("http_proxy::on_connected() connection failed: %s\n", ec.message().c_str());
+++ m_server_connection.close();
+++ error(503, "Service Temporarily Unavailable");
+++ return;
+++ }
+++
+++ std::printf("http_proxy: connected\n");
+++
+++ write_server_send_buffer();
+++
+++ m_server_connection.async_read_some(
+++ asio::buffer(m_in_buffer, sizeof(m_in_buffer))
+++ , std::bind(&http_proxy::on_server_receive, this, _1, _2));
+++ }
+++
+++ void http_proxy::write_server_send_buffer()
+++ {
+++ if (m_writing_to_server) return;
+++ m_writing_to_server = true;
+++ m_server_connection.async_write_some(asio::buffer(
+++ &m_server_out_buffer[0], m_num_server_out_bytes)
+++ , std::bind(&http_proxy::on_server_write, this, _1, _2));
+++ }
+++
+++ void http_proxy::on_server_write(error_code const& ec, size_t bytes_transferred)
+++ {
+++ m_writing_to_server = false;
+++ if (ec)
+++ {
+++ std::printf("http_proxy::on_server_write: (%d) %s\n"
+++ , ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++ memmove(&m_server_out_buffer[0], &m_server_out_buffer[bytes_transferred]
+++ , m_num_server_out_bytes - bytes_transferred);
+++ m_num_server_out_bytes -= int(bytes_transferred);
+++
+++ if (m_num_server_out_bytes > 0)
+++ write_server_send_buffer();
+++ }
+++
+++ // we received some data from the server, forward it to the server
+++ void http_proxy::on_server_receive(boost::system::error_code const& ec
+++ , std::size_t bytes_transferred)
+++ {
+++ if (ec)
+++ {
+++ std::printf("http_proxy: error reading from server: (%d) %s\n"
+++ , ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++ asio::async_write(m_client_connection, asio::buffer(&m_in_buffer[0], bytes_transferred)
+++ , std::bind(&http_proxy::on_server_forward, this, _1, _2));
+++ }
+++
+++ void http_proxy::on_server_forward(error_code const& ec
+++ , size_t)
+++ {
+++ if (ec)
+++ {
+++ std::printf("http_proxy: error writing to client: (%d) %s\n"
+++ , ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++ m_server_connection.async_read_some(
+++ sim::asio::buffer(m_in_buffer, sizeof(m_in_buffer))
+++ , std::bind(&http_proxy::on_server_receive, this, _1, _2));
+++ }
+++
+++ void http_proxy::stop()
+++ {
+++ m_close = true;
+++ m_listen_socket.close();
+++ }
+++
+++ void http_proxy::close_connection()
+++ {
+++ m_num_client_in_bytes = 0;
+++ m_num_server_out_bytes = 0;
+++ m_num_in_bytes = 0;
+++
+++ error_code err;
+++ m_client_connection.close(err);
+++ if (err)
+++ {
+++ std::printf("http_proxy::close: failed to close client connection (%d) %s\n"
+++ , err.value(), err.message().c_str());
+++ }
+++ m_server_connection.close(err);
+++ if (err)
+++ {
+++ std::printf("http_proxy::close: failed to close server connection (%d) %s\n"
+++ , err.value(), err.message().c_str());
+++ }
+++
+++ if (m_close) return;
+++
+++ // now we can accept another connection
+++ m_listen_socket.async_accept(m_client_connection, m_ep
+++ , std::bind(&http_proxy::on_accept, this, _1));
+++ }
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/http_server.cpp
++@@ -0,0 +1,425 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include "simulator/http_server.hpp"
+++
+++#include <functional>
+++#include <cstdio> // for printf
+++
+++using namespace sim::asio;
+++using namespace sim::asio::ip;
+++using namespace std::placeholders;
+++
+++using boost::system::error_code;
+++
+++namespace sim
+++{
+++ using namespace aux;
+++
+++ namespace {
+++ char const* find(char const* hay, int const hsize
+++ , char const* needle, int const nsize)
+++ {
+++ for (int i = 0; i < hsize - nsize + 1; ++i)
+++ {
+++ if (memcmp(hay + i, needle, nsize) == 0) return hay + i;
+++ }
+++ return nullptr;
+++ }
+++ }
+++
+++ std::string trim(std::string s)
+++ {
+++ if (s.empty()) return s;
+++
+++ int start = 0;
+++ int end = int(s.size());
+++ while (strchr(" \r\n\t", s[start]) != NULL && start < end)
+++ {
+++ ++start;
+++ }
+++
+++ while (strchr(" \r\n\t", s[end-1]) != NULL && end > start)
+++ {
+++ --end;
+++ }
+++ return s.substr(start, end - start);
+++ }
+++
+++ std::string lower_case(std::string s)
+++ {
+++ std::string ret;
+++ std::transform(s.begin(), s.end(), std::back_inserter(ret)
+++ , [](char c) { return static_cast<char>(tolower(c)); } );
+++ return ret;
+++ }
+++
+++ std::string normalize(const std::string& s)
+++ {
+++ std::vector<std::string> elements;
+++ char const* start = s.c_str();
+++ if (*start == '/') ++start;
+++ char const* slash = strchr(start, '/');
+++ while (slash != NULL)
+++ {
+++ std::string element(start, slash - start);
+++ if (element != "..")
+++ {
+++ elements.push_back(element);
+++ } else if (!elements.empty())
+++ {
+++ elements.erase(elements.end()-1);
+++ }
+++ start = slash + 1;
+++ slash = strchr(start, '/');
+++ }
+++ elements.push_back(start);
+++
+++ std::string ret;
+++ for (auto const& e : elements)
+++ {
+++ ret += '/';
+++ ret += e;
+++ }
+++
+++ return ret;
+++ }
+++
+++ // TODO: extra_header should be a std::vector
+++ std::string send_response(int code, char const* status_message
+++ , int len, char const** extra_header)
+++ {
+++ std::string ret = "HTTP/1.1 " + std::to_string(code) + " " + status_message + "\r\n";
+++
+++ ret += "content-length: " + std::to_string(len) + "\r\n";
+++
+++ if (extra_header)
+++ {
+++ ret += extra_header[0];
+++ ret += extra_header[1];
+++ ret += extra_header[2];
+++ ret += extra_header[3];
+++ }
+++ ret += "\r\n";
+++
+++ return ret;
+++ }
+++
+++ http_server::http_server(io_context& ios, unsigned short listen_port, int flags)
+++ : m_ios(ios)
+++ , m_listen_socket(ios)
+++ , m_connection(ios)
+++ , m_bytes_used(0)
+++ , m_close(false)
+++ , m_flags(flags)
+++ {
+++ address local_ip = ios.get_ips().front();
+++ if (local_ip.is_v4())
+++ {
+++ m_listen_socket.open(tcp::v4());
+++ m_listen_socket.bind(tcp::endpoint(address_v4::any(), listen_port));
+++ }
+++ else
+++ {
+++ m_listen_socket.open(tcp::v6());
+++ m_listen_socket.bind(tcp::endpoint(address_v6::any(), listen_port));
+++ }
+++ m_listen_socket.listen();
+++
+++ m_listen_socket.async_accept(m_connection, m_ep
+++ , std::bind(&http_server::on_accept, this, _1));
+++ }
+++
+++ void http_server::on_accept(error_code const& ec)
+++ {
+++ if (ec)
+++ {
+++ std::printf("http_server::on_accept: (%d) %s\n"
+++ , ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++ ++m_accepted_connections;
+++
+++ std::printf("http_server accepted connection from: %s : %d\n",
+++ m_ep.address().to_string().c_str(), m_ep.port());
+++
+++ read();
+++ }
+++
+++ void http_server::register_handler(std::string const& path, handler_t h)
+++ {
+++ m_handlers[path] = std::move(h);
+++ }
+++
+++ void http_server::register_content(std::string const& path
+++ , std::int64_t const size, generator_t gen)
+++ {
+++ m_handlers[path] = [gen,size](std::string, std::string, std::map<std::string, std::string>& hdr)
+++ {
+++ std::int64_t start = 0;
+++ std::int64_t end = size;
+++
+++ auto it = hdr.find("range");
+++ bool const range_req = it != hdr.end();
+++ if (range_req)
+++ {
+++ std::string range = it->second;
+++ // skip "bytes "
+++ range = range.substr(range.find_first_of('=') + 1);
+++ start = std::stoll(range.substr(0, range.find('-')));
+++ end = std::stoll(range.substr(range.find_first_of('-') + 1)) + 1;
+++ }
+++
+++ std::string header = "Content-Range: bytes " + std::to_string(start)
+++ + "-" + std::to_string(end-1) + "/" + std::to_string(end-start) + "\r\n";
+++ char const* extra_headers[4] = { header.c_str(), "", "", ""};
+++
+++ return sim::send_response(range_req ? 206 : 200
+++ , range_req ? "Partial Content" : "OK"
+++ , int(end - start), range_req ? extra_headers : nullptr)
+++ + gen(start, end - start);
+++ };
+++ }
+++
+++ void http_server::register_redirect(std::string const& path, std::string const& target)
+++ {
+++ m_handlers[path] = [target](std::string, std::string, std::map<std::string, std::string>&)
+++ {
+++ std::string header = "Location: " + target + "\r\n";
+++ char const* extra_headers[4] = { header.c_str(), "", "", ""};
+++ return sim::send_response(301, "Moved Permanently", 0, extra_headers);
+++ };
+++ }
+++
+++ void http_server::register_stall_handler(std::string const& path){
+++ m_stall_handlers.insert(path);
+++ }
+++
+++ void http_server::read()
+++ {
+++ if (m_bytes_used >= int(m_recv_buffer.size()) / 2)
+++ {
+++ m_recv_buffer.resize((std::max)(500, m_bytes_used * 2));
+++ }
+++ assert(int(m_recv_buffer.size()) > m_bytes_used);
+++ m_connection.async_read_some(asio::buffer(&m_recv_buffer[m_bytes_used]
+++ , m_recv_buffer.size() - m_bytes_used)
+++ , std::bind(&http_server::on_read, this, _1, _2));
+++ }
+++
+++ http_request parse_request(char const* start, int len)
+++ {
+++ http_request ret;
+++
+++ char const* const end_of_request = start + len;
+++ char const* const space = find(start, len, " ", 1);
+++ if (space == nullptr)
+++ {
+++ std::printf("http_server: failed to parse request:\n%s\n"
+++ , std::string(start, len).c_str());
+++ throw std::runtime_error("parse failed");
+++ }
+++
+++ char const* const space2 = find(space + 1
+++ , int(len - (space - start + 1)), " ", 1);
+++ if (space2 == nullptr)
+++ {
+++ std::printf("http_server: failed to parse request:\n%s\n"
+++ , std::string(start, len).c_str());
+++ throw std::runtime_error("parse failed");
+++ }
+++ ret.method.assign(start, space);
+++ ret.req.assign(space+1, space2);
+++ if (ret.method != "CONNECT") {
+++ ret.path.assign(normalize(ret.req.substr(0, ret.req.find_first_of('?'))));
+++ } else {
+++ ret.path.assign(ret.req);
+++ }
+++ std::printf("parse_request: %s %s [%s]\n"
+++ , ret.method.c_str(), ret.path.c_str(), ret.req.c_str());
+++
+++ char const* header = find(space2, int(len - (space2 - start)), "\r\n", 2);
+++ while (header != end_of_request - 4)
+++ {
+++ if (header == nullptr)
+++ {
+++ std::printf("http_server: failed to parse request:\n%s\n"
+++ , std::string(start, len).c_str());
+++ throw std::runtime_error("parse failed");
+++ }
+++ char const* const next = find(header + 2
+++ , int(len - (header + 2 - start)), "\r\n", 2);
+++ char const* const value = static_cast<char const*>(memchr(header, ':', len - (header - start)));
+++ if (value == nullptr || next == nullptr || value > next)
+++ {
+++ std::printf("http_server: failed to parse request:\n%s\n"
+++ , std::string(start, len).c_str());
+++ throw std::runtime_error("parse failed");
+++ }
+++
+++ ret.headers[lower_case(trim(std::string(header, value)))]
+++ = trim(std::string(value+1, next));
+++
+++ header = next;
+++ }
+++ return ret;
+++ }
+++
+++ int find_request_len(char const* buf, int const len)
+++ {
+++ char const* end_of_request = find(buf, len, "\r\n\r\n", 4);
+++ if (end_of_request == nullptr) return -1;
+++ return int(end_of_request - buf + 4);
+++ }
+++
+++ void http_server::on_read(error_code const& ec, size_t bytes_transferred) try
+++ {
+++ if (ec)
+++ {
+++ std::printf("http_server::on_read: (%d) %s\n"
+++ , ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++ m_bytes_used += int(bytes_transferred);
+++
+++ int const req_len = find_request_len(m_recv_buffer.data(), m_bytes_used);
+++ if (req_len < 0)
+++ {
+++ read();
+++ return;
+++ }
+++
+++ http_request req = parse_request(m_recv_buffer.data(), req_len);
+++
+++ m_recv_buffer.erase(m_recv_buffer.begin(), m_recv_buffer.begin() + req_len);
+++ m_bytes_used -= req_len;
+++
+++ auto it = m_handlers.find(req.path);
+++ if (it == m_handlers.end())
+++ {
+++ if (m_stall_handlers.find(req.path) != m_stall_handlers.end())
+++ {
+++ return;
+++ }
+++ // no handler found, 404
+++ m_send_buffer = send_response(404, "Not Found");
+++ }
+++ else
+++ {
+++ m_send_buffer = it->second(req.method, req.req, req.headers);
+++ }
+++
+++ // decide whether to close the connection after this response, and signal
+++ // it to the client appropriately.
+++ bool close;
+++ if (m_flags & http_1_0)
+++ {
+++ // an HTTP/1.0 server closes after every response and does not use the
+++ // Connection header (that is an HTTP/1.1 mechanism). Downgrade the
+++ // status line so the client detects this from the protocol version.
+++ close = true;
+++ auto const ver = m_send_buffer.find("HTTP/1.1");
+++ if (ver != std::string::npos)
+++ m_send_buffer.replace(ver, 8, "HTTP/1.0");
+++ }
+++ else
+++ {
+++ // close if the client asked us to, or if this server is not
+++ // configured for keep-alive. When we do, advertise it with a
+++ // "Connection: close" response header so the client knows not to
+++ // reuse the socket (rather than discovering it via a failed write).
+++ close = lower_case(req.headers["connection"]) == "close"
+++ || !(m_flags & keep_alive);
+++ if (close)
+++ {
+++ auto const status_end = m_send_buffer.find("\r\n");
+++ if (status_end != std::string::npos)
+++ {
+++ assert(m_send_buffer.find("Connection:") == std::string::npos);
+++ m_send_buffer.insert(status_end + 2, "Connection: close\r\n");
+++ }
+++ }
+++ }
+++
+++ async_write(m_connection, asio::buffer(m_send_buffer.data()
+++ , m_send_buffer.size()), std::bind(&http_server::on_write
+++ , this, _1, _2, close));
+++ }
+++ catch (std::exception& e)
+++ {
+++ std::printf("http_server::on_read() failed: %s\n"
+++ , e.what());
+++ close_connection();
+++ }
+++
+++ void http_server::on_write(error_code const& ec
+++ , size_t /* bytes_transferred */
+++ , bool close)
+++ {
+++ if (ec)
+++ {
+++ std::printf("http_server::on_write: (%d) %s\n"
+++ , ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++ if (!close)
+++ {
+++ // try to read another request out of the buffer
+++ post(m_ios, std::bind(&http_server::on_read, this, error_code(), 0));
+++ }
+++ else
+++ {
+++ close_connection();
+++ }
+++ }
+++
+++ void http_server::stop()
+++ {
+++ m_close = true;
+++ m_listen_socket.close();
+++ }
+++
+++ void http_server::close_connection()
+++ {
+++ m_recv_buffer.clear();
+++ m_bytes_used = 0;
+++
+++ error_code err;
+++ m_connection.close(err);
+++ if (err)
+++ {
+++ std::printf("http_server::close: failed to close connection (%d) %s\n"
+++ , err.value(), err.message().c_str());
+++ return;
+++ }
+++
+++ if (m_close) return;
+++
+++ // now we can accept another connection
+++ m_listen_socket.async_accept(m_connection, m_ep
+++ , std::bind(&http_server::on_accept, this, _1));
+++ }
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/io_service.cpp
++@@ -0,0 +1,272 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++
+++#include <boost/make_shared.hpp>
+++#include <boost/system/error_code.hpp>
+++
+++namespace sim { namespace asio {
+++
+++ io_context::io_context(sim::simulation& sim)
+++ : io_context(sim, std::vector<asio::ip::address>())
+++ {}
+++
+++ io_context::io_context(sim::simulation& sim, asio::ip::address const& ip)
+++ : io_context(sim, std::vector<asio::ip::address>{ip})
+++ {}
+++
+++ io_context::io_context(sim::simulation& sim, std::vector<asio::ip::address> const& ips)
+++ : m_sim(sim)
+++ , m_ips(ips)
+++ , m_stopped(false)
+++ {
+++ for (auto const& ip : m_ips)
+++ {
+++ m_outgoing_route[ip] = m_sim.config().outgoing_route(ip);
+++ m_incoming_route[ip] = m_sim.config().incoming_route(ip);
+++ }
+++ m_sim.add_io_service(this);
+++ }
+++
+++ io_context::~io_context()
+++ {
+++ m_sim.remove_io_service(this);
+++ }
+++
+++ // this constructor is never meant to be called (hence the assert). It only
+++ // exists to satisfy interfaces that require a default-like constructor. The
+++ // null reference is deliberate, so suppress the warning about it.
+++#if defined __clang__
+++#pragma clang diagnostic push
+++#pragma clang diagnostic ignored "-Wnull-dereference"
+++#elif defined __GNUC__
+++#pragma GCC diagnostic push
+++#pragma GCC diagnostic ignored "-Wnull-dereference"
+++#endif
+++ io_context::io_context(std::size_t)
+++ : m_sim(*reinterpret_cast<sim::simulation*>(0))
+++ {
+++ assert(false);
+++ }
+++#if defined __clang__
+++#pragma clang diagnostic pop
+++#elif defined __GNUC__
+++#pragma GCC diagnostic pop
+++#endif
+++
+++ int io_context::get_path_mtu(const asio::ip::address& source, const asio::ip::address& dest) const
+++ {
+++ // TODO: it would be nice to actually traverse the virtual network nodes
+++ // and ask for their MTU instead
+++ assert(std::count(m_ips.begin(), m_ips.end(), source) > 0 && "source address must be a local address to this node/io_context");
+++ return m_sim.config().path_mtu(source, dest);
+++ }
+++
+++ void io_context::stop()
+++ {
+++ // TODO: cancel all outstanding handler associated with this io_context
+++ m_stopped = true;
+++ }
+++
+++ bool io_context::stopped() const
+++ {
+++ return m_stopped;
+++ }
+++
+++ void io_context::restart()
+++ {
+++ m_stopped = false;
+++ }
+++
+++ std::size_t io_context::run()
+++ {
+++ assert(false);
+++ return 0;
+++ }
+++
+++ std::size_t io_context::run(boost::system::error_code&)
+++ {
+++ assert(false);
+++ return 0;
+++ }
+++
+++ std::size_t io_context::poll()
+++ {
+++ assert(false);
+++ return 0;
+++ }
+++
+++ std::size_t io_context::poll(boost::system::error_code&)
+++ {
+++ assert(false);
+++ return 0;
+++ }
+++
+++ std::size_t io_context::poll_one()
+++ {
+++ assert(false);
+++ return 0;
+++ }
+++
+++ std::size_t io_context::poll_one(boost::system::error_code&)
+++ {
+++ assert(false);
+++ return 0;
+++ }
+++
+++ // private interface
+++
+++ void io_context::add_timer(high_resolution_timer* t)
+++ {
+++ m_sim.add_timer(t);
+++ }
+++
+++ void io_context::remove_timer(high_resolution_timer* t)
+++ {
+++ m_sim.remove_timer(t);
+++ }
+++
+++ boost::asio::io_context& io_context::get_internal_service()
+++ { return m_sim.get_internal_service(); }
+++
+++ ip::tcp::endpoint io_context::bind_socket(ip::tcp::socket* socket
+++ , ip::tcp::endpoint ep, boost::system::error_code& ec)
+++ {
+++ assert(!m_ips.empty() && "you cannot use an internal io_context (one without an IP address) for creating and binding sockets");
+++ if (ep.address() == ip::address_v4::any())
+++ {
+++ auto it = std::find_if(m_ips.begin(), m_ips.end()
+++ , [](ip::address const& ip) { return ip.is_v4(); } );
+++ if (it == m_ips.end())
+++ {
+++ ec.assign(boost::system::errc::address_not_available
+++ , boost::system::generic_category());
+++ return ip::tcp::endpoint();
+++ }
+++ // TODO: pick the first local endpoint for now. In the future we may
+++ // want have a bias toward
+++ ep.address(*it);
+++ }
+++ else if (ep.address() == ip::address_v6::any())
+++ {
+++ auto it = std::find_if(m_ips.begin(), m_ips.end()
+++ , [](ip::address const& ip) { return ip.is_v6(); } );
+++ if (it == m_ips.end())
+++ {
+++ ec.assign(boost::system::errc::address_not_available
+++ , boost::system::generic_category());
+++ return ip::tcp::endpoint();
+++ }
+++ // TODO: pick the first local endpoint for now. In the future we may
+++ // want have a bias toward
+++ ep.address(*it);
+++ }
+++ else if (std::count(m_ips.begin(), m_ips.end(), ep.address()) == 0)
+++ {
+++ // you can only bind to the IP assigned to this node.
+++ // TODO: support loopback
+++ ec.assign(boost::system::errc::address_not_available
+++ , boost::system::generic_category());
+++ return ip::tcp::endpoint();
+++ }
+++
+++ return m_sim.bind_socket(socket, ep, ec);
+++ }
+++
+++ void io_context::unbind_socket(ip::tcp::socket* socket
+++ , const ip::tcp::endpoint& ep)
+++ {
+++ m_sim.unbind_socket(socket, ep);
+++ }
+++
+++ void io_context::rebind_socket(asio::ip::tcp::socket* prev, asio::ip::tcp::socket* s, asio::ip::tcp::endpoint ep)
+++ {
+++ m_sim.rebind_socket(prev, s, ep);
+++ }
+++
+++ ip::udp::endpoint io_context::bind_udp_socket(ip::udp::socket* socket
+++ , ip::udp::endpoint ep, boost::system::error_code& ec)
+++ {
+++ assert(!m_ips.empty() && "you cannot use an internal io_context (one without an IP address) for creating and binding sockets");
+++ if (ep.address() == ip::address_v4::any())
+++ {
+++ auto it = std::find_if(m_ips.begin(), m_ips.end()
+++ , [](ip::address const& ip) { return ip.is_v4(); });
+++ if (it == m_ips.end())
+++ {
+++ ec.assign(boost::system::errc::address_not_available
+++ , boost::system::generic_category());
+++ return ip::udp::endpoint();
+++ }
+++ // TODO: pick the first local endpoint for now. In the future we may
+++ // want have a bias toward
+++ ep.address(*it);
+++ }
+++ else if (ep.address() == ip::address_v6::any())
+++ {
+++ auto it = std::find_if(m_ips.begin(), m_ips.end()
+++ , [](ip::address const& ip) { return ip.is_v6(); });
+++ if (it == m_ips.end())
+++ {
+++ ec.assign(boost::system::errc::address_not_available
+++ , boost::system::generic_category());
+++ return ip::udp::endpoint();
+++ }
+++ // TODO: pick the first local endpoint for now. In the future we may
+++ // want have a bias toward
+++ ep.address(*it);
+++ }
+++ else if (std::count(m_ips.begin(), m_ips.end(), ep.address()) == 0)
+++ {
+++ // you can only bind to the IP assigned to this node.
+++ // TODO: support loopback
+++ ec.assign(boost::system::errc::address_not_available
+++ , boost::system::generic_category());
+++ return ip::udp::endpoint();
+++ }
+++
+++ return m_sim.bind_udp_socket(socket, ep, ec);
+++ }
+++
+++ void io_context::unbind_udp_socket(ip::udp::socket* socket
+++ , const ip::udp::endpoint& ep)
+++ {
+++ m_sim.unbind_udp_socket(socket, ep);
+++ }
+++
+++ void io_context::rebind_udp_socket(asio::ip::udp::socket* socket, asio::ip::udp::endpoint ep)
+++ {
+++ m_sim.rebind_udp_socket(socket, ep);
+++ }
+++
+++ std::shared_ptr<aux::channel> io_context::internal_connect(ip::tcp::socket* s
+++ , ip::tcp::endpoint const& target, boost::system::error_code& ec)
+++ {
+++ return m_sim.internal_connect(s, target, ec);
+++ }
+++
+++ route io_context::find_udp_socket(asio::ip::udp::socket const& socket
+++ , ip::udp::endpoint const& ep)
+++ {
+++ return m_sim.find_udp_socket(socket, ep);
+++ }
+++
+++} // asio
+++} // sim
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/nat.cpp
++@@ -0,0 +1,47 @@
+++/*
+++
+++Copyright (c) 2018, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/nat.hpp"
+++#include "simulator/simulator.hpp"
+++#include "simulator/packet.hpp"
+++#include <string>
+++
+++namespace sim {
+++
+++ nat::nat(asio::ip::address external_addr) : m_external_addr(external_addr) {}
+++
+++ void nat::incoming_packet(aux::packet p)
+++ {
+++ // unconditionally replacing the "from" address is fine because of our
+++ // simplified network model where the two paths of a connection are set up
+++ // independently, and we can set up the nat hop only on the outgoing path
+++ p.from.address(m_external_addr);
+++ if (p.channel) {
+++ p.channel->visible_ep[0].address(m_external_addr);
+++ }
+++ forward_packet(std::move(p));
+++ }
+++
+++ // used for visualization
+++ std::string nat::label() const
+++ {
+++ return std::string("NAT [") + m_external_addr.to_string() + "]";
+++ }
+++
+++} // sim
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/pcap.cpp
++@@ -0,0 +1,204 @@
+++/*
+++
+++Copyright (c) 2017, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/pcap.hpp"
+++#include "simulator/chrono.hpp"
+++#include "simulator/packet.hpp"
+++
+++using sim::chrono::duration_cast;
+++using sim::chrono::seconds;
+++
+++using sim::asio::ip::address_v4;
+++using sim::asio::ip::tcp;
+++using sim::asio::ip::udp;
+++
+++namespace sim { namespace aux {
+++
+++namespace {
+++
+++ template <typename T, typename cond = typename std::enable_if<std::is_pod<T>::value>::type>
+++ void write(std::fstream& o, T const& value)
+++ { o.write(reinterpret_cast<char const*>(&value), sizeof(value)); }
+++
+++ // documented here:
+++ // http://www.tcpdump.org/linktypes.html
+++ std::uint32_t const LINKTYPE_RAW = 101;
+++
+++ struct ip_header
+++ {
+++ std::uint8_t version_len;
+++ std::uint8_t dscp;
+++ std::uint16_t length;
+++ std::uint16_t identification;
+++ std::uint16_t fragment;
+++ std::uint8_t ttl;
+++ std::uint8_t protocol;
+++ std::uint16_t checksum;
+++ std::uint32_t source_ip;
+++ std::uint32_t destination_ip;
+++ };
+++
+++ struct udp_header
+++ {
+++ std::uint16_t src_port;
+++ std::uint16_t dst_port;
+++ std::uint16_t length;
+++ std::uint16_t checksum;
+++ };
+++
+++ struct tcp_header
+++ {
+++ std::uint16_t src_port;
+++ std::uint16_t dst_port;
+++ std::uint32_t seq_nr;
+++ std::uint32_t ack_nr;
+++ std::uint8_t offset;
+++ std::uint8_t flags;
+++ std::uint16_t window_size;
+++ std::uint16_t checksum;
+++ std::uint16_t urgent;
+++ };
+++}
+++
+++ pcap::pcap(char const* filename)
+++ : m_file(filename, std::ios_base::out | std::ios_base::trunc | std::ios_base::binary)
+++ {
+++ // file format documented here:
+++ // https://wiki.wireshark.org/Development/LibpcapFileFormat
+++ // write pcap file header
+++ write(m_file, std::uint32_t(0xa1b2c3d4)); // magic number
+++ write(m_file, std::uint16_t(2)); // versopm major
+++ write(m_file, std::uint16_t(4)); // versopm minor
+++ write(m_file, std::int32_t(0)); // thiszone
+++ write(m_file, std::uint32_t(0)); // sigfigs
+++ write(m_file, std::uint32_t(0xffff)); // snaplen
+++ write(m_file, LINKTYPE_RAW); // network
+++ }
+++
+++ void write_ip_header(std::fstream& file, int const size, int const protocol
+++ , address_v4 const source, address_v4 const dest)
+++ {
+++ ip_header const header = {
+++ (4 << 4) | 5, // version_len
+++ 0, // dscp
+++ htons(std::uint16_t(size)), // length
+++ 0, // identification
+++ 0, // fragment
+++ 200, // ttl
+++ std::uint8_t(protocol), // protocol
+++ 0, // checksum
+++ htonl(std::uint32_t(source.to_uint())), // source ip
+++ htonl(std::uint32_t(dest.to_uint())) // destination ip
+++ };
+++
+++ write(file, header);
+++ }
+++
+++ void write_udp_header(std::fstream& file, int const size, int const src_port
+++ , int const dst_port)
+++ {
+++ assert(src_port != 0);
+++ assert(dst_port != 0);
+++ udp_header const header = {
+++ htons(std::uint16_t(src_port)), // source port
+++ htons(std::uint16_t(dst_port)), // destination port
+++ htons(std::uint16_t(sizeof(udp_header) + size)), // length
+++ 0 // checksum
+++ };
+++
+++ write(file, header);
+++ }
+++
+++ void write_tcp_header(std::fstream& file, int const src_port
+++ , int const dst_port, std::uint32_t const seq_nr)
+++ {
+++ assert(src_port != 0);
+++ assert(dst_port != 0);
+++ tcp_header const header = {
+++ htons(std::uint16_t(src_port)), // source port
+++ htons(std::uint16_t(dst_port)), // destination port
+++ htonl(seq_nr), // sequence number
+++ std::uint32_t(0), // acknowledgement number
+++ std::uint8_t(5 << 4), // header size (data offset)
+++ std::uint8_t(0), // flags
+++ htons(std::uint16_t(65535)), // window size
+++ std::uint16_t(0), // checksum
+++ std::uint16_t(0) // urgent offset
+++ };
+++
+++ write(file, header);
+++ }
+++
+++ void pcap::log_tcp(packet const& p, tcp::endpoint const src
+++ , tcp::endpoint const dst)
+++ {
+++ // synthesize IP/TCP header and write packet
+++ auto const now = chrono::high_resolution_clock::now();
+++
+++ // just an arbitrary posix time used as starting point
+++ std::uint32_t const sim_start_time = 441794304;
+++ std::uint32_t const secs = static_cast<std::uint32_t>(duration_cast<chrono::seconds>(now.time_since_epoch()).count());
+++ std::uint32_t const usecs = static_cast<std::uint32_t>(duration_cast<chrono::microseconds>(now.time_since_epoch() - seconds(secs)).count());
+++
+++ std::uint32_t const packet_size = static_cast<std::uint32_t>(sizeof(ip_header) + sizeof(tcp_header) + p.buffer.size());
+++
+++ write(m_file, sim_start_time + secs);
+++ write(m_file, usecs);
+++ write(m_file, packet_size);
+++ write(m_file, packet_size);
+++
+++ // 6 is the protocol number for TCP
+++ write_ip_header(m_file, packet_size, 6
+++ , src.address().to_v4(), dst.address().to_v4());
+++
+++ // TODO: if the packet has error set with asio::error::eof
+++ // set the FIN flag
+++ write_tcp_header(m_file, p.from.port(), dst.port(), p.byte_counter);
+++
+++ m_file.write(reinterpret_cast<char const*>(p.buffer.data()), p.buffer.size());
+++ }
+++
+++ void pcap::log_udp(packet const& p, udp::endpoint const src
+++ , udp::endpoint const dst)
+++ {
+++ // synthesize IP/UDP header and write packet
+++ auto const now = chrono::high_resolution_clock::now();
+++
+++ // just an arbitrary posix time used as starting point
+++ std::uint32_t const sim_start_time = 441794304;
+++ std::uint32_t const secs = static_cast<std::uint32_t>(duration_cast<chrono::seconds>(now.time_since_epoch()).count());
+++ std::uint32_t const usecs = static_cast<std::uint32_t>(duration_cast<chrono::microseconds>(now.time_since_epoch() - seconds(secs)).count());
+++
+++ std::uint32_t const packet_size = static_cast<std::uint32_t>(sizeof(ip_header) + sizeof(udp_header) + p.buffer.size());
+++
+++ write(m_file, sim_start_time + secs);
+++ write(m_file, usecs);
+++ write(m_file, packet_size);
+++ write(m_file, packet_size);
+++
+++ // 17 is the protocol number for UDP
+++ write_ip_header(m_file, packet_size, 17
+++ , src.address().to_v4(), dst.address().to_v4());
+++
+++ write_udp_header(m_file, static_cast<int>(p.buffer.size()), p.from.port(), static_cast<int>(dst.port()));
+++
+++ m_file.write(reinterpret_cast<char const*>(p.buffer.data()), p.buffer.size());
+++ }
+++
+++}}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/queue.cpp
++@@ -0,0 +1,142 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/queue.hpp"
+++#include "simulator/handler_allocator.hpp"
+++#include <functional>
+++#include <cstdio> // for printf
+++
+++typedef sim::chrono::high_resolution_clock::time_point time_point;
+++typedef sim::chrono::high_resolution_clock::duration duration;
+++
+++namespace sim
+++{
+++ using namespace aux;
+++
+++ queue::queue(asio::io_context& ios
+++ , int bandwidth
+++ , chrono::high_resolution_clock::duration propagation_delay
+++ , int max_queue_size
+++ , std::string name)
+++ : m_max_queue_size(max_queue_size)
+++ , m_forwarding_latency(propagation_delay)
+++ , m_bandwidth(bandwidth)
+++ , m_queue_size(0)
+++ , m_node_name(name)
+++ , m_forward_timer(ios)
+++ , m_last_forward(chrono::high_resolution_clock::now())
+++ {}
+++
+++ std::string queue::label() const
+++ {
+++ char ret[400];
+++ int p = std::snprintf(ret, sizeof(ret), "%s\n", m_node_name.c_str());
+++
+++ if (m_bandwidth != 0)
+++ {
+++ p += std::snprintf(ret + p, sizeof(ret) - p, "rate: %d kB/s\n"
+++ , m_bandwidth / 1000);
+++ }
+++
+++ if (m_queue_size != 0)
+++ {
+++ p += std::snprintf(ret + p, sizeof(ret) - p, "queue: %d kB\n"
+++ , m_queue_size / 1000);
+++ }
+++
+++ if (m_forwarding_latency.count() != 0)
+++ {
+++ p += std::snprintf(ret + p, sizeof(ret) - p, "latency: %d ms\n"
+++ , int(chrono::duration_cast<chrono::milliseconds>(m_forwarding_latency).count()));
+++ }
+++
+++ return ret;
+++ }
+++
+++ void queue::incoming_packet(aux::packet p)
+++ {
+++ const int packet_size = int(p.buffer.size() + p.overhead);
+++
+++ // tail-drop
+++ if (p.ok_to_drop()
+++ && m_max_queue_size > 0
+++ && m_queue_size + packet_size > m_max_queue_size)
+++ {
+++ // if any hop on the network drops a packet, it has to return it to the
+++ // sender.
+++ auto drop_fun = std::move(p.drop_fun);
+++ if (drop_fun) drop_fun(std::move(p));
+++ return;
+++ }
+++
+++ time_point const now = chrono::high_resolution_clock::now();
+++
+++ m_queue.emplace_back(now + m_forwarding_latency, std::move(p));
+++ m_queue_size += packet_size;
+++ if (m_queue.size() > 1) return;
+++
+++ begin_send_next_packet();
+++ }
+++
+++ void queue::begin_send_next_packet()
+++ {
+++ time_point now = chrono::high_resolution_clock::now();
+++
+++ if (m_queue.front().ts > now)
+++ {
+++ m_forward_timer.expires_at(m_queue.front().ts);
+++ m_forward_timer.async_wait(make_malloc(std::bind(&queue::begin_send_next_packet
+++ , this)));
+++ return;
+++ }
+++
+++ m_last_forward = now;
+++ if (m_bandwidth == 0)
+++ {
+++ post(m_forward_timer.get_executor(), make_malloc(std::bind(&queue::next_packet_sent
+++ , this)));
+++ return;
+++ }
+++ const double nanoseconds_per_byte = 1000000000.0
+++ / double(m_bandwidth);
+++
+++ aux::packet const& p = m_queue.front().pkt;
+++ const int packet_size = int(p.buffer.size() + p.overhead);
+++
+++ m_last_forward += chrono::duration_cast<duration>(chrono::nanoseconds(
+++ boost::int64_t(nanoseconds_per_byte * packet_size)));
+++
+++ m_forward_timer.expires_at(m_last_forward);
+++ m_forward_timer.async_wait(make_malloc(std::bind(&queue::next_packet_sent
+++ , this)));
+++ }
+++
+++ void queue::next_packet_sent()
+++ {
+++ aux::packet p = std::move(m_queue.front().pkt);
+++ m_queue.erase(m_queue.begin());
+++ const int packet_size = int(p.buffer.size() + p.overhead);
+++ m_queue_size -= packet_size;
+++
+++ forward_packet(std::move(p));
+++
+++ if (m_queue.size())
+++ begin_send_next_packet();
+++ }
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/resolver.cpp
++@@ -0,0 +1,143 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include "simulator/handler_allocator.hpp"
+++#include <functional>
+++
+++typedef sim::chrono::high_resolution_clock::time_point time_point;
+++typedef sim::chrono::high_resolution_clock::duration duration;
+++
+++using namespace std::placeholders;
+++
+++namespace sim {
+++namespace asio {
+++namespace ip {
+++
+++ template<typename Protocol>
+++ basic_resolver<Protocol>::basic_resolver(io_context& ios)
+++ : m_ios(&ios)
+++ , m_timer(ios)
+++ {}
+++
+++ template<typename Protocol>
+++ basic_resolver<Protocol>::basic_resolver(basic_resolver<Protocol>&&) noexcept = default;
+++
+++ template<typename Protocol>
+++ basic_resolver<Protocol>& basic_resolver<Protocol>::operator=(basic_resolver<Protocol>&&) noexcept = default;
+++
+++ template<typename Protocol>
+++ void basic_resolver<Protocol>::async_resolve(std::string hostname, char const* service
+++ , aux::function<void(boost::system::error_code const&, results_type)> handler)
+++ {
+++ std::vector<asio::ip::address> result;
+++ boost::system::error_code ec;
+++
+++ const chrono::high_resolution_clock::time_point start_time =
+++ m_queue.empty() ? chrono::high_resolution_clock::now() :
+++ m_queue.front().completion_time;
+++
+++ assert(!m_ios->get_ips().empty() && "internal io service objects can only "
+++ "be used for timers");
+++
+++ // if the hostname is an IP address, resolve it immediately
+++ asio::ip::address addr = make_address_v4(hostname, ec);
+++ if (ec) addr = make_address_v6(hostname, ec);
+++ if (!ec)
+++ {
+++ const chrono::high_resolution_clock::time_point t = chrono::high_resolution_clock::now()
+++ + chrono::microseconds(1);
+++ results_type ips;
+++ int const port = atoi(service);
+++ assert(port >= 0 && port <= 0xffff);
+++ ips.emplace_back(
+++ typename Protocol::endpoint(addr, static_cast<unsigned short>(port))
+++ , hostname, service);
+++ result_t res{t, ec, std::move(ips), std::move(handler) };
+++ m_queue.insert(m_queue.begin(), std::move(res));
+++ m_timer.expires_at(m_queue.front().completion_time);
+++ m_timer.async_wait(aux::make_malloc(std::bind(&basic_resolver::on_lookup, this, _1)));
+++ return;
+++ }
+++ ec.clear();
+++
+++ const chrono::high_resolution_clock::time_point completion_time =
+++ start_time
+++ + m_ios->sim().config().hostname_lookup(m_ios->get_ips().front(), hostname
+++ , result, ec);
+++
+++ results_type ips;
+++
+++ int const port = atoi(service);
+++ assert(port >= 0 && port <= 0xffff);
+++
+++ for (auto const& ip : result)
+++ {
+++ ips.emplace_back(
+++ typename Protocol::endpoint(ip, static_cast<unsigned short>(port))
+++ , hostname, service);
+++ }
+++
+++ result_t res{ completion_time, ec, std::move(ips), std::move(handler)};
+++ m_queue.emplace_back(std::move(res));
+++
+++ m_timer.expires_at(m_queue.front().completion_time);
+++ m_timer.async_wait(aux::make_malloc(std::bind(&basic_resolver::on_lookup, this, _1)));
+++ }
+++
+++ template<typename Protocol>
+++ void basic_resolver<Protocol>::on_lookup(boost::system::error_code const& ec)
+++ {
+++ if (ec == asio::error::operation_aborted) return;
+++
+++ if (m_queue.empty()) return;
+++
+++ typename queue_t::value_type v = std::move(m_queue.front());
+++ m_queue.erase(m_queue.begin());
+++
+++ // once the handler is called, it's possible the last reference keeping
+++ // this object (basic_resolver) alive is released and we're deleted. Make
+++ // sure to not touch any members after the handler in that case.
+++ bool const empty = m_queue.empty();
+++ v.handler(v.err, std::move(v.ips));
+++ if (empty) return;
+++
+++ m_timer.expires_at(m_queue.front().completion_time);
+++ m_timer.async_wait(aux::make_malloc(std::bind(&basic_resolver::on_lookup, this, _1)));
+++ }
+++
+++ template<typename Protocol>
+++ void basic_resolver<Protocol>::cancel()
+++ {
+++ queue_t q;
+++ m_queue.swap(q);
+++ for (auto& r : q)
+++ {
+++ r.err = asio::error::operation_aborted;
+++ post(m_timer.get_executor(), aux::make_malloc(std::bind(std::move(r.handler)
+++ , r.err, std::move(r.ips))));
+++ }
+++ }
+++
+++ // explicitly instantiate the functions
+++ template struct basic_resolver<udp>;
+++ template struct basic_resolver<tcp>;
+++}
+++}
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/simulation.cpp
++@@ -0,0 +1,381 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include "simulator/packet.hpp"
+++#include "simulator/pcap.hpp"
+++
+++#include <tuple> // for tie
+++#include <memory> // for make_shared
+++#include <cstdio> // for printf
+++#include <iostream>
+++#include <stdexcept> // for std::runtime_error
+++
+++using namespace sim::asio;
+++
+++namespace sim
+++{
+++ simulation::simulation(configuration& config)
+++ : m_config(config)
+++ , m_internal_ios(new asio::io_context(*this))
+++ , m_service(1)
+++ {
+++ sim::chrono::reset_clock();
+++ m_config.build(*this);
+++ }
+++
+++ simulation::~simulation()
+++ {
+++ m_config.clear();
+++
+++ assert(m_timer_queue.empty());
+++ }
+++
+++ std::size_t simulation::run() try
+++ {
+++ std::size_t ret = 0;
+++ std::size_t last_executed = 0;
+++
+++ // Detect a runaway loop where events keep firing but simulated time
+++ // never advances - typically a timer being repeatedly scheduled at the
+++ // current time (a 100% CPU spin that would otherwise hang run()
+++ // forever). Legitimate bursts of same-timestamp events are finite, so
+++ // a large threshold reliably distinguishes them from an unbounded spin.
+++ chrono::high_resolution_clock::time_point prev_time
+++ = chrono::high_resolution_clock::now();
+++ std::int64_t stalled_iterations = 0;
+++ constexpr std::int64_t max_stalled_iterations = 1000;
+++
+++ do {
+++
+++ m_service.restart();
+++ last_executed = m_service.poll();
+++ ret += last_executed;
+++
+++ chrono::high_resolution_clock::time_point now
+++ = chrono::high_resolution_clock::now();
+++
+++ std::lock_guard<std::mutex> l(m_timer_queue_mutex);
+++ if (!m_timer_queue.empty()) {
+++ asio::high_resolution_timer* next_timer = *m_timer_queue.begin();
+++ chrono::high_resolution_clock::fast_forward(next_timer->expiry() - now);
+++
+++ now = chrono::high_resolution_clock::now();
+++
+++ while (!m_timer_queue.empty()
+++ && (*m_timer_queue.begin())->expiry() <= now) {
+++
+++ next_timer = *m_timer_queue.begin();
+++ m_timer_queue.erase(m_timer_queue.begin());
+++ next_timer->fire(boost::system::error_code());
+++ ++last_executed;
+++ ++ret;
+++ }
+++ }
+++
+++ if (last_executed > 0) {
+++ if (now == prev_time) {
+++ if (++stalled_iterations > max_stalled_iterations) {
+++ throw std::runtime_error("libsimulator: simulated time "
+++ "has not advanced for too many consecutive iterations "
+++ "while events keep firing. The simulation is stuck in a "
+++ "busy loop, typically a timer repeatedly scheduled at "
+++ "the current time (a 100% CPU spin).");
+++ }
+++ } else {
+++ stalled_iterations = 0;
+++ prev_time = now;
+++ }
+++ }
+++
+++// std::fprintf(stderr, "run: last_executed: %d stopped: %d timer-queue: %d\n"
+++// , int(last_executed), m_stopped, int(m_timer_queue.size()));
+++ } while (last_executed > 0 && !m_stopped);
+++
+++// std::fprintf(stderr, "exiting simulation::run(): last_executed: %d stopped: %d timer-queue: %d ret: %d\n"
+++// , int(last_executed), m_stopped, int(m_timer_queue.size()), int(ret));
+++ return ret;
+++ }
+++ catch (...)
+++ {
+++ // cancel all outstanding timers
+++ // we make a copy, since cancelling the timers will mutate m_timer_queue
+++ auto queue = m_timer_queue;
+++ for (auto& t : queue)
+++ t->cancel();
+++
+++ auto listen_sockets = m_listen_sockets;
+++ for (auto& s : listen_sockets)
+++ s.second->cancel();
+++
+++ auto udp_sockets = m_udp_sockets;
+++ for (auto& s : udp_sockets)
+++ s.second->cancel();
+++ m_stopped = true;
+++ throw;
+++ }
+++
+++ void simulation::stop() { m_stopped = true; }
+++ bool simulation::stopped() const { return m_stopped; }
+++ void simulation::restart() { m_stopped = false; }
+++
+++ void simulation::add_timer(asio::high_resolution_timer* t)
+++ {
+++ assert(!m_stopped);
+++ if (t->expiry() == sim::chrono::high_resolution_clock::now())
+++ {
+++ std::fprintf(stderr, "WARNING: timer scheduled for current time!\n");
+++ }
+++ std::lock_guard<std::mutex> l(m_timer_queue_mutex);
+++ // make sure we get a deterministic ordering of timers with the same
+++ // expiration time
+++ auto it = std::upper_bound(m_timer_queue.begin(), m_timer_queue.end(), t, timer_compare());
+++ m_timer_queue.insert(it, t);
+++ }
+++
+++ void simulation::remove_timer(asio::high_resolution_timer* t)
+++ {
+++ std::lock_guard<std::mutex> l(m_timer_queue_mutex);
+++ if (m_timer_queue.empty()) return;
+++ timer_queue_t::iterator begin;
+++ timer_queue_t::iterator end;
+++ std::tie(begin, end) = std::equal_range(m_timer_queue.begin(), m_timer_queue.end(), t, timer_compare());
+++ if (begin == end) return;
+++ begin = std::find(begin, end, t);
+++ if (begin == end) return;
+++ m_timer_queue.erase(begin);
+++ }
+++
+++ void simulation::rebind_socket(ip::tcp::socket* prev, ip::tcp::socket* s, ip::tcp::endpoint ep)
+++ {
+++ auto i = m_listen_sockets.find(ep);
+++ assert(i != m_listen_sockets.end());
+++ if (i->second != prev) return;
+++ i->second = s;
+++ }
+++
+++ ip::tcp::endpoint simulation::bind_socket(ip::tcp::socket* socket
+++ , ip::tcp::endpoint ep, boost::system::error_code& ec)
+++ {
+++ assert(ep.address() != boost::asio::ip::address());
+++
+++ if (ep.port() < 1024 && ep.port() > 0)
+++ {
+++ // emulate process not running as root
+++ ec = boost::asio::error::access_denied;
+++ return ip::tcp::endpoint();
+++ }
+++
+++ if (ep.port() == 0)
+++ {
+++ // if the socket is being bound to port 0, it means the system picks a
+++ // free port. We want to avoid re-using ports, because that may confuse
+++ // wireshark when threading together the TCP streams.
+++ ep.port(m_next_bind_port++);
+++ if (m_next_bind_port > 65534) m_next_bind_port = 2000;
+++
+++ listen_socket_iter_t i = m_listen_sockets.lower_bound(ep);
+++ while (i != m_listen_sockets.end() && i->first == ep)
+++ {
+++ ep.port(ep.port() + 1);
+++ if (ep.port() > 65530)
+++ {
+++ ec = boost::asio::error::address_in_use;
+++ return ip::tcp::endpoint();
+++ }
+++ i = m_listen_sockets.lower_bound(ep);
+++ }
+++ }
+++
+++ listen_socket_iter_t i = m_listen_sockets.lower_bound(ep);
+++ if (i != m_listen_sockets.end() && i->first == ep)
+++ {
+++ ec = boost::asio::error::address_in_use;
+++ return ip::tcp::endpoint();
+++ }
+++
+++ m_listen_sockets.insert(i, std::make_pair(ep, socket));
+++ ec.clear();
+++ return ep;
+++ }
+++
+++ void simulation::unbind_socket(ip::tcp::socket* socket
+++ , const ip::tcp::endpoint& ep)
+++ {
+++ listen_socket_iter_t i = m_listen_sockets.find(ep);
+++ if (i == m_listen_sockets.end() || i->second != socket) return;
+++ m_listen_sockets.erase(i);
+++ }
+++
+++ void simulation::rebind_udp_socket(ip::udp::socket* socket, ip::udp::endpoint ep)
+++ {
+++ auto i = m_udp_sockets.find(ep);
+++ assert(i != m_udp_sockets.end());
+++ i->second = socket;
+++ }
+++
+++ ip::udp::endpoint simulation::bind_udp_socket(ip::udp::socket* socket
+++ , ip::udp::endpoint ep, boost::system::error_code& ec)
+++ {
+++ assert(ep.address() != boost::asio::ip::address());
+++
+++ if (ep.port() < 1024 && ep.port() > 0)
+++ {
+++ // emulate process not running as root
+++ ec = boost::asio::error::access_denied;
+++ return ip::udp::endpoint();
+++ }
+++
+++ if (ep.port() == 0)
+++ {
+++ // if the socket is being bound to port 0, it means the system picks a
+++ // free port.
+++
+++ ep.port(m_next_bind_port++);
+++ if (m_next_bind_port > 65534) m_next_bind_port = 2000;
+++ udp_socket_iter_t i = m_udp_sockets.lower_bound(ep);
+++ while (i != m_udp_sockets.end() && i->first == ep)
+++ {
+++ ep.port(ep.port() + 1);
+++ if (ep.port() > 65530)
+++ {
+++ ec = boost::asio::error::address_in_use;
+++ return ip::udp::endpoint();
+++ }
+++ i = m_udp_sockets.lower_bound(ep);
+++ }
+++ }
+++
+++ udp_socket_iter_t i = m_udp_sockets.lower_bound(ep);
+++ if (i != m_udp_sockets.end() && i->first == ep)
+++ {
+++ ec = boost::asio::error::address_in_use;
+++ return ip::udp::endpoint();
+++ }
+++
+++ m_udp_sockets.insert(i, std::make_pair(ep, socket));
+++ ec.clear();
+++ return ep;
+++ }
+++
+++ void simulation::unbind_udp_socket(ip::udp::socket* socket
+++ , const ip::udp::endpoint& ep)
+++ {
+++ udp_socket_iter_t i = m_udp_sockets.find(ep);
+++ if (i == m_udp_sockets.end() || i->second != socket) return;
+++ m_udp_sockets.erase(i);
+++ }
+++
+++ std::shared_ptr<aux::channel> simulation::internal_connect(
+++ asio::ip::tcp::socket* s
+++ , ip::tcp::endpoint const& target, boost::system::error_code& ec)
+++ {
+++ // find remote socket
+++ listen_sockets_t::iterator i = m_listen_sockets.find(target);
+++ if (i == m_listen_sockets.end())
+++ {
+++ ec = boost::system::error_code(error::connection_refused);
+++ return std::shared_ptr<aux::channel>();
+++ }
+++
+++ // make sure it's a listening socket
+++ ip::tcp::socket* remote = i->second;
+++ if (!remote->internal_is_listening())
+++ {
+++ ec = boost::system::error_code(error::connection_refused);
+++ return std::shared_ptr<aux::channel>();
+++ }
+++
+++ // create a channel
+++ std::shared_ptr<aux::channel> c = std::make_shared<aux::channel>();
+++
+++ asio::ip::tcp::endpoint from = s->local_bound_to(ec);
+++
+++ route network_route = m_config.channel_route(from.address()
+++ , target.address());
+++ c->hops[0] = remote->get_outgoing_route() + network_route + s->get_incoming_route();
+++ c->hops[1] = s->get_outgoing_route() + network_route + remote->get_incoming_route();
+++
+++ c->ep[0] = s->local_bound_to(ec);
+++ c->ep[1] = remote->local_bound_to(ec);
+++
+++ c->visible_ep[0] = s->local_bound_to(ec);
+++ c->visible_ep[1] = remote->local_bound_to(ec);
+++
+++ aux::packet p;
+++ p.type = aux::packet::type_t::syn;
+++ p.overhead = 28;
+++ p.from = asio::ip::udp::endpoint(from.address(), from.port());
+++ p.channel = c;
+++ if (ec) return std::shared_ptr<aux::channel>();
+++
+++ p.hops = c->hops[1];
+++
+++ forward_packet(std::move(p));
+++
+++ return c;
+++ }
+++
+++ route simulation::find_udp_socket(asio::ip::udp::socket const& socket
+++ , ip::udp::endpoint const& ep)
+++ {
+++ udp_socket_iter_t i = m_udp_sockets.find(ep);
+++ if (i == m_udp_sockets.end())
+++ return route();
+++
+++ ip::udp::endpoint src = socket.local_bound_to();
+++ route network_route = m_config.channel_route(src.address(), ep.address());
+++
+++ // ask the socket for its incoming route
+++ network_route.append(i->second->get_incoming_route());
+++
+++ return network_route;
+++ }
+++
+++ void simulation::add_io_service(asio::io_context* ios)
+++ {
+++ bool added = m_nodes.insert(ios).second;
+++ (void)added;
+++ assert(added);
+++ }
+++
+++ void simulation::remove_io_service(asio::io_context* ios)
+++ {
+++ auto it = m_nodes.find(ios);
+++ assert(it != m_nodes.end());
+++ m_nodes.erase(it);
+++ }
+++
+++ std::vector<io_context*> simulation::get_all_io_services() const
+++ {
+++ std::vector<io_context*> ret;
+++ ret.reserve(m_nodes.size());
+++ std::remove_copy_if(
+++ m_nodes.begin(), m_nodes.end(), std::back_inserter(ret)
+++ , [](io_context* ios) { return ios->get_ips().empty(); });
+++ return ret;
+++ }
+++
+++ void simulation::log_pcap(char const* filename)
+++ {
+++ std::printf("saving packet capture to: \"%s\"\n", filename);
+++ m_pcap = std::unique_ptr<aux::pcap>(new aux::pcap(filename));
+++ }
+++
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/simulator.cpp
++@@ -0,0 +1,262 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include "simulator/packet.hpp"
+++
+++#include <functional>
+++#include <unordered_set>
+++#include <set>
+++#include <cstdio> // for printf
+++
+++#include "simulator/push_warnings.hpp"
+++#include <boost/system/error_code.hpp>
+++#include "simulator/pop_warnings.hpp"
+++
+++typedef sim::chrono::high_resolution_clock::time_point time_point;
+++typedef sim::chrono::high_resolution_clock::duration duration;
+++
+++namespace sim {
+++namespace asio {
+++namespace ip {
+++
+++ default_config default_cfg;
+++
+++} // ip
+++} // asio
+++
+++void forward_packet(aux::packet p)
+++{
+++ std::shared_ptr<sink> next_hop = p.hops.pop_front();
+++ if (!next_hop)
+++ {
+++ std::fprintf(stderr, "packet lost\n");
+++ return;
+++ }
+++ next_hop->incoming_packet(std::move(p));
+++}
+++
+++namespace
+++{
+++ // this is a dummy sink for endpoints, wrapping an io_context
+++ struct endpoint : sink
+++ {
+++ endpoint(asio::io_context& ioc)
+++ : m_ioc(ioc)
+++ {}
+++
+++ virtual void incoming_packet(aux::packet /* p */) override final { assert(false); }
+++
+++ virtual std::string label() const override final
+++ {
+++ std::string ret;
+++ for (auto const& ip : m_ioc.get_ips())
+++ {
+++ ret += ip.to_string();
+++ ret += " ";
+++ }
+++ return ret;
+++ }
+++
+++ virtual std::string attributes() const override final
+++ {
+++ return "shape=ellipse";
+++ }
+++
+++ private:
+++ asio::io_context& m_ioc;
+++ };
+++}
+++
+++namespace
+++{
+++ std::string escape_label(std::string n)
+++ {
+++ std::string ret;
+++ for (auto c : n)
+++ {
+++ if (c == '\n')
+++ {
+++ ret += "\\n";
+++ continue;
+++ }
+++ if (c == '\"')
+++ {
+++ ret += "\\\"";
+++ continue;
+++ }
+++ ret += c;
+++ }
+++ return ret;
+++ }
+++}
+++
+++void dump_network_graph(simulation const& s, const std::string& filename)
+++{
+++ // all edges (directed).
+++ std::set<std::pair<std::shared_ptr<sink>, std::shared_ptr<sink>>> edges;
+++
+++ // all network nodes
+++ std::unordered_set<std::shared_ptr<sink>> nodes;
+++
+++ // local nodes (subgrapgs)
+++ std::vector<std::unordered_set<std::shared_ptr<sink>>> local_nodes;
+++
+++ const std::vector<asio::io_context*> io_services = s.get_all_io_services();
+++
+++ for (auto ioc : io_services)
+++ {
+++ std::shared_ptr<sink> ep = std::make_shared<endpoint>(*ioc);
+++ local_nodes.push_back(std::unordered_set<std::shared_ptr<sink>>());
+++ local_nodes.back().insert(ep);
+++
+++ for (auto const& ip : ioc->get_ips())
+++ {
+++ route in = ioc->get_incoming_route(ip);
+++ route out = ioc->get_outgoing_route(ip);
+++
+++ // this is the outgoing node for this endpoint. This is
+++ // how it connects to the network.
+++ const std::shared_ptr<sink> egress = out.empty() ? ep : out.last();
+++
+++ // first add both the incoming and outgoing chains
+++ std::shared_ptr<sink> prev;
+++ while (!in.empty())
+++ {
+++ auto node = in.pop_front();
+++ local_nodes.back().insert(node);
+++ if (prev) edges.insert({prev, node});
+++ prev = node;
+++ }
+++ if (prev) edges.insert({prev, ep});
+++
+++ prev = ep;
+++ while (!out.empty())
+++ {
+++ auto node = out.pop_front();
+++ local_nodes.back().insert(node);
+++ edges.insert({prev, node});
+++ prev = node;
+++ }
+++
+++ // then connect the endpoint of those chains to the rest of the network.
+++ // Since the network may be arbitrarily complex, we actually have to
+++ // completely iterate over all other endpoints
+++
+++ for (auto ios2 : io_services)
+++ {
+++ for (auto const& ip2 : ios2->get_ips())
+++ {
+++ route network = s.config().channel_route(
+++ ip, ip2);
+++
+++ std::shared_ptr<sink> last = ios2->get_incoming_route(ip2).next_hop();
+++
+++ prev = egress;
+++ while (!network.empty())
+++ {
+++ auto node = network.pop_front();
+++ nodes.insert(node);
+++ edges.insert({prev, node});
+++ prev = node;
+++ }
+++ edges.insert({prev, last});
+++ }
+++ }
+++ }
+++ }
+++
+++ // by now, the nodes and edges should represent the complete graph. Render it
+++ // into dot.
+++
+++ FILE* f = fopen(filename.c_str(), "w+");
+++
+++ std::fprintf(f, "digraph network {\n"
+++ "concentrate=true;\n"
+++ "overlap=scale;\n"
+++ "splines=true;\n");
+++
+++ std::fprintf(f, "\n// nodes\n\n");
+++
+++ for (const auto& n : nodes)
+++ {
+++ std::string attributes = n->attributes();
+++ std::fprintf(f, " \"%p\" [label=\"%s\",style=\"filled\",color=\"red\"%s%s];\n"
+++ , static_cast<void*>(n.get())
+++ , escape_label(n->label()).c_str()
+++ , attributes.empty() ? "" : ", "
+++ , attributes.c_str());
+++ }
+++
+++ std::fprintf(f, "\n// local networks\n\n");
+++
+++ int idx = 0;
+++ for (auto ln : local_nodes)
+++ {
+++ std::fprintf(f, "subgraph cluster_%d {\n", idx++);
+++
+++ for (const auto& n : ln)
+++ {
+++ std::string attributes = n->attributes();
+++ std::fprintf(f, " \"%p\" [label=\"%s\",style=\"filled\",color=\"green\"%s%s];\n"
+++ , static_cast<void*>(n.get())
+++ , escape_label(n->label()).c_str()
+++ , attributes.empty() ? "" : ", "
+++ , attributes.c_str());
+++ }
+++
+++ std::fprintf(f, "}\n");
+++ }
+++
+++ std::fprintf(f, "\n// edges\n\n");
+++
+++ while (!edges.empty())
+++ {
+++ auto edge = *edges.begin();
+++ edges.erase(edges.begin());
+++
+++ std::fprintf(f, "\"%p\" -> \"%p\"\n"
+++ , static_cast<void*>(edge.first.get())
+++ , static_cast<void*>(edge.second.get()));
+++ }
+++
+++ std::fprintf(f, "}\n");
+++ fclose(f);
+++}
+++
+++namespace aux {
+++
+++ int channel::remote_idx(const asio::ip::tcp::endpoint& self) const
+++ {
+++ if (ep[0] == self) return 1;
+++ if (ep[1] == self) return 0;
+++ assert(false && "invalid socket");
+++ return -1;
+++ }
+++
+++ int channel::self_idx(const asio::ip::tcp::endpoint& self) const
+++ {
+++ if (ep[0] == self) return 0;
+++ if (ep[1] == self) return 1;
+++ assert(false && "invalid socket");
+++ return -1;
+++ }
+++
+++} // aux
+++} // sim
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/sink_forwarder.cpp
++@@ -0,0 +1,45 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/sink_forwarder.hpp"
+++#include "simulator/packet.hpp"
+++
+++namespace sim { namespace aux {
+++
+++ sink_forwarder::sink_forwarder(sink* dst)
+++ : m_dst(dst)
+++ {}
+++
+++ void sink_forwarder::incoming_packet(packet p)
+++ {
+++ if (m_dst == nullptr) return;
+++ m_dst->incoming_packet(std::move(p));
+++ }
+++
+++ std::string sink_forwarder::label() const
+++ {
+++ return m_dst ? m_dst->label() : "";
+++ }
+++
+++ void sink_forwarder::reset(sink* s)
+++ {
+++ m_dst = s;
+++ }
+++
+++}}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/socks_server.cpp
++@@ -0,0 +1,1033 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include "simulator/socks_server.hpp"
+++
+++#include <functional>
+++#include <cstdint>
+++#include <cinttypes>
+++#include <cstdio> // for printf
+++
+++using namespace sim::asio;
+++using namespace sim::asio::ip;
+++
+++using boost::system::error_code;
+++
+++namespace sim
+++{
+++ using namespace aux;
+++
+++ socks_server::socks_server(io_context& ios, unsigned short listen_port, int version
+++ , std::uint32_t const flags)
+++ : m_ios(ios)
+++ , m_listen_socket(ios)
+++ , m_conn(std::make_shared<socks_connection>(m_ios, version, m_cmd_counts, flags, m_bind_port))
+++ , m_version(version)
+++ , m_flags(flags)
+++ {
+++ m_cmd_counts.fill(0);
+++ address local_ip = ios.get_ips().front();
+++ if (local_ip.is_v4())
+++ {
+++ m_listen_socket.open(tcp::v4());
+++ m_listen_socket.bind(tcp::endpoint(address_v4::any(), listen_port));
+++ }
+++ else
+++ {
+++ m_listen_socket.open(tcp::v6());
+++ m_listen_socket.bind(tcp::endpoint(address_v6::any(), listen_port));
+++ }
+++ m_listen_socket.listen();
+++
+++ m_listen_socket.async_accept(m_conn->socket(), m_ep
+++ , std::bind(&socks_server::on_accept, this, std::placeholders::_1));
+++ }
+++
+++ void socks_server::on_accept(error_code const& ec)
+++ {
+++ if (ec == asio::error::operation_aborted)
+++ return;
+++
+++ if (ec)
+++ {
+++ std::printf("socks_server::on_accept: (%d) %s\n"
+++ , ec.value(), ec.message().c_str());
+++ return;
+++ }
+++
+++ std::printf("socks_server accepted connection from: %s : %d\n",
+++ m_ep.address().to_string().c_str(), m_ep.port());
+++
+++ m_conn->start();
+++
+++ // create a new connection to accept into
+++ m_conn = std::make_shared<socks_connection>(m_ios, m_version, m_cmd_counts, m_flags, m_bind_port);
+++
+++ // now we can accept another connection
+++ m_listen_socket.async_accept(m_conn->socket(), m_ep
+++ , std::bind(&socks_server::on_accept, this, std::placeholders::_1));
+++ }
+++
+++ void socks_server::stop()
+++ {
+++ m_close = true;
+++ m_listen_socket.close();
+++ }
+++
+++ socks_connection::socks_connection(asio::io_context& ios
+++ , int version, std::array<int, 3>& cmd_counts, std::uint32_t const flags, int& bind_port)
+++ : m_bind_port(bind_port)
+++ , m_ios(ios)
+++ , m_udp_resolver(ios)
+++ , m_resolver(m_ios)
+++ , m_client_connection(ios)
+++ , m_server_connection(m_ios)
+++ , m_bind_socket(m_ios)
+++ , m_udp_associate(m_ios)
+++ , m_num_out_bytes(0)
+++ , m_num_in_bytes(0)
+++ , m_version(version)
+++ , m_command(0)
+++ , m_cmd_counts(cmd_counts)
+++ , m_flags(flags)
+++ {
+++ }
+++
+++ void socks_connection::start()
+++ {
+++ if (m_version == 4)
+++ {
+++ asio::async_read(m_client_connection, asio::buffer(&m_out_buffer[0], 9)
+++ , std::bind(&socks_connection::on_request1, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
+++ } else {
+++ // read protocol version and number of auth-methods
+++ asio::async_read(m_client_connection, asio::buffer(&m_out_buffer[0], 2)
+++ , std::bind(&socks_connection::on_handshake1, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
+++ }
+++ }
+++
+++ void socks_connection::on_handshake1(error_code const& ec, size_t bytes_transferred)
+++ {
+++ if (ec || bytes_transferred != 2)
+++ {
+++ std::printf("socks_connection::on_handshake1: (%d) %s\n"
+++ , ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++ if (m_out_buffer[0] != 4 && m_out_buffer[0] != 5)
+++ {
+++ std::printf("socks_connection::on_handshake1: unexpected socks protocol version: %d"
+++ , int(m_out_buffer[0]));
+++ close_connection();
+++ return;
+++ }
+++
+++ int num_methods = unsigned(m_out_buffer[1]);
+++
+++ // read list of auth-methods
+++ asio::async_read(m_client_connection, asio::buffer(&m_out_buffer[0],
+++ num_methods)
+++ , std::bind(&socks_connection::on_handshake2, shared_from_this()
+++ , std::placeholders::_1, std::placeholders::_2));
+++ }
+++
+++ void socks_connection::on_handshake2(error_code const& ec, size_t bytes_transferred)
+++ {
+++ if (ec)
+++ {
+++ std::printf("socks_connection::on_handshake2: (%d) %s\n"
+++ , ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++ if (std::count(m_out_buffer, m_out_buffer + bytes_transferred, 0) == 0)
+++ {
+++ std::printf("socks_connection: could not find auth-method 0 (no-auth) in socks handshake\n");
+++ close_connection();
+++ return;
+++ }
+++
+++ m_in_buffer[0] = 5; // socks version
+++ m_in_buffer[1] = 0; // auth-method (no-auth)
+++
+++ asio::async_write(m_client_connection, asio::buffer(&m_in_buffer[0], 2)
+++ , std::bind(&socks_connection::on_handshake3, shared_from_this()
+++ , std::placeholders::_1, std::placeholders::_2));
+++ }
+++
+++ void socks_connection::on_handshake3(error_code const& ec, size_t bytes_transferred)
+++ {
+++ if (ec || bytes_transferred != 2)
+++ {
+++ std::printf("socks_connection::on_handshake3: (%d) %s\n"
+++ , ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++ asio::async_read(m_client_connection, asio::buffer(&m_out_buffer[0], 10)
+++ , std::bind(&socks_connection::on_request1, shared_from_this()
+++ , std::placeholders::_1, std::placeholders::_2));
+++ }
+++
+++ void socks_connection::on_request1(error_code const& ec, size_t bytes_transferred)
+++ {
+++ size_t const expected = m_version == 4 ? 9 : 10;
+++ if (ec || bytes_transferred != expected)
+++ {
+++ std::printf("socks_connection::on_request1: (%d) %s\n"
+++ , ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++// +----+-----+-------+------+----------+----------+
+++// |VER | CMD | RSV | ATYP | DST.ADDR | DST.PORT |
+++// +----+-----+-------+------+----------+----------+
+++// | 1 | 1 | X'00' | 1 | Variable | 2 |
+++// +----+-----+-------+------+----------+----------+
+++
+++ int const version = m_out_buffer[0];
+++ int const command = m_out_buffer[1];
+++ m_command = command;
+++ ++m_cmd_counts[command - 1];
+++
+++ if (version != m_version)
+++ {
+++ std::printf("socks_connection::on_request1: unexpected socks protocol version: %d expected: %d\n"
+++ , int(m_out_buffer[0]), m_version);
+++ close_connection();
+++ return;
+++ }
+++
+++ if (m_version == 4)
+++ {
+++ if (command != 1 && command != 2)
+++ {
+++ std::printf("socks_connection::on_request1: unexpected socks command: %d\n"
+++ , command);
+++ close_connection();
+++ return;
+++ }
+++
+++ std::uint16_t port = m_out_buffer[2] & 0xff;
+++ port <<= 8;
+++ port |= m_out_buffer[3] & 0xff;
+++
+++ std::uint32_t addr = m_out_buffer[4] & 0xff;
+++ addr <<= 8;
+++ addr |= m_out_buffer[5] & 0xff;
+++ addr <<= 8;
+++ addr |= m_out_buffer[6] & 0xff;
+++ addr <<= 8;
+++ addr |= m_out_buffer[7] & 0xff;
+++
+++ if (m_out_buffer[8] != 0)
+++ {
+++ // in this case, we would have to read one byte at a time until we
+++ // get to the null terminator.
+++ std::printf("socks_connection::on_request1: username in SOCKS4 mode not supported\n");
+++ close_connection();
+++ return;
+++ }
+++ asio::ip::tcp::endpoint target(asio::ip::address_v4(addr), port);
+++ if (command == 1)
+++ {
+++ open_forward_connection(target);
+++ }
+++ else if (command == 2)
+++ {
+++ bind_connection(target);
+++ }
+++
+++ return;
+++ }
+++
+++ if (command != 1 && command != 2 && command != 3)
+++ {
+++ std::printf("socks_connection::on_request1: unexpected command: %d\n"
+++ , command);
+++ close_connection();
+++ return;
+++ }
+++
+++ if (m_out_buffer[2] != 0)
+++ {
+++ std::printf("socks_connection::on_request1: reserved byte is non-zero: %d\n"
+++ , int(m_out_buffer[2]));
+++ close_connection();
+++ return;
+++ }
+++
+++ int atyp = unsigned(m_out_buffer[3]);
+++
+++ if (atyp != 1 && atyp != 3 && atyp != 4)
+++ {
+++ std::printf("socks_connection::on_request1: unexpected address type in SOCKS request: %d\n"
+++ , atyp);
+++ close_connection();
+++ return;
+++ }
+++
+++ std::printf("socks_connection: received %s request address type: %d\n"
+++ , command == 1 ? "CONNECT"
+++ : command == 2 ? "BIND"
+++ : "UDP_ASSOCIATE", atyp);
+++
+++ switch (atyp)
+++ {
+++ case 1: { // IPv4 address (we have the whole request already)
+++
+++// +----+-----+-------+------+----------+----------+
+++// |VER | CMD | RSV | ATYP | BND.ADDR | BND.PORT |
+++// +----+-----+-------+------+----------+----------+
+++// | 1 | 1 | X'00' | 1 | 4 | 2 |
+++// +----+-----+-------+------+----------+----------+
+++
+++ std::uint32_t addr = m_out_buffer[4] & 0xff;
+++ addr <<= 8;
+++ addr |= m_out_buffer[5] & 0xff;
+++ addr <<= 8;
+++ addr |= m_out_buffer[6] & 0xff;
+++ addr <<= 8;
+++ addr |= m_out_buffer[7] & 0xff;
+++
+++ std::uint16_t port = m_out_buffer[8] & 0xff;
+++ port <<= 8;
+++ port |= m_out_buffer[9] & 0xff;
+++
+++ asio::ip::tcp::endpoint target(asio::ip::address_v4(addr), port);
+++ if (command == 1)
+++ {
+++ open_forward_connection(target);
+++ }
+++ else if (command == 2)
+++ {
+++ bind_connection(target);
+++ }
+++ else if (command == 3)
+++ {
+++ if (target.address() == address())
+++ {
+++ target.address(m_client_connection.remote_endpoint().address());
+++ }
+++ udp_associate(target);
+++ }
+++
+++ break;
+++ }
+++ case 3: { // domain name
+++
+++// +----+-----+-------+------+-----+----------+----------+
+++// |VER | CMD | RSV | ATYP | LEN | BND.ADDR | BND.PORT |
+++// +----+-----+-------+------+-----+----------+----------+
+++// | 1 | 1 | X'00' | 1 | 1 | Variable | 2 |
+++// +----+-----+-------+------+-----+----------+----------+
+++
+++ if (command == 2)
+++ {
+++ std::printf("ERROR: cannot BIND to hostname address (only IPv4 or IPv6 addresses)\n");
+++ close_connection();
+++ return;
+++ }
+++
+++ const int len = std::uint8_t(m_out_buffer[4]);
+++ // we already read an address of length 4, assuming it was an IPv4
+++ // address. Now, with a domain name, one of those bytes was the
+++ // length-prefix, but we still read 3 bytes already.
+++ const int additional_bytes = len - 3;
+++ asio::async_read(m_client_connection, asio::buffer(&m_out_buffer[10], additional_bytes)
+++ , std::bind(&socks_connection::on_request_domain_name
+++ , shared_from_this(), std::placeholders::_1, std::placeholders::_2));
+++ break;
+++ }
+++ case 4: // IPv6 address
+++
+++// +----+-----+-------+------+----------+----------+
+++// |VER | CMD | RSV | ATYP | BND.ADDR | BND.PORT |
+++// +----+-----+-------+------+----------+----------+
+++// | 1 | 1 | X'00' | 1 | 16 | 2 |
+++// +----+-----+-------+------+----------+----------+
+++
+++ std::printf("ERROR: unsupported address type %d\n", atyp);
+++ close_connection();
+++ }
+++ }
+++
+++ void socks_connection::on_request_domain_name(error_code const& ec, size_t bytes_transferred)
+++ {
+++ if (ec)
+++ {
+++ std::printf("socks_connection::on_request_domain_name(%s): (%d) %s\n"
+++ , command(), ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++ int const buffer_size = int(10 + bytes_transferred);
+++
+++ std::uint16_t port = m_out_buffer[buffer_size - 2] & 0xff;
+++ port <<= 8;
+++ port |= m_out_buffer[buffer_size - 1] & 0xff;
+++
+++ std::string hostname(&m_out_buffer[5], std::uint8_t(m_out_buffer[4]));
+++ std::printf("socks_connection::on_request_domain_name(%s): hostname: %s port: %d\n"
+++ , command(), hostname.c_str(), port);
+++
+++ char port_str[10];
+++ std::snprintf(port_str, sizeof(port_str), "%d", port);
+++ m_resolver.async_resolve(hostname, port_str
+++ , std::bind(&socks_connection::on_request_domain_lookup
+++ , shared_from_this(), std::placeholders::_1, std::placeholders::_2));
+++ }
+++
+++ void socks_connection::on_request_domain_lookup(boost::system::error_code const& ec
+++ , asio::ip::tcp::resolver::results_type const ips)
+++ {
+++ if (ec || ips.empty())
+++ {
+++ if (ec)
+++ {
+++ std::printf("socks_connection::on_request_domain_lookup(%s): (%d) %s\n"
+++ , command(), ec.value(), ec.message().c_str());
+++ }
+++ else
+++ {
+++ std::printf("socks_connection::on_request_domain_lookup(%s): empty response\n"
+++ , command());
+++ }
+++
+++// +----+-----+-------+------+----------+----------+
+++// |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT |
+++// +----+-----+-------+------+----------+----------+
+++// | 1 | 1 | X'00' | 1 | Variable | 2 |
+++// +----+-----+-------+------+----------+----------+
+++
+++ m_in_buffer[0] = char(m_version); // version
+++ m_in_buffer[1] = 4; // response (host unreachable)
+++ m_in_buffer[2] = 0; // reserved
+++ m_in_buffer[3] = 1; // IPv4
+++ memset(&m_in_buffer[4], 0, 4);
+++ m_in_buffer[8] = 0; // port
+++ m_in_buffer[9] = 0;
+++
+++ auto self = shared_from_this();
+++ asio::async_write(m_client_connection
+++ , asio::buffer(&m_in_buffer[0], 10)
+++ , [=](boost::system::error_code const&, size_t)
+++ {
+++ self->close_connection();
+++ });
+++ return;
+++ }
+++
+++ std::printf("socks_connection::on_request_domain_lookup(%s): connecting to: %s port: %d\n"
+++ , command()
+++ , ips.front().endpoint().address().to_string().c_str()
+++ , ips.front().endpoint().port());
+++ open_forward_connection(ips.front().endpoint());
+++ }
+++
+++ void socks_connection::open_forward_connection(const asio::ip::tcp::endpoint& target)
+++ {
+++ std::printf("socks_connection::open_forward_connection(%s): connecting to %s port %d\n"
+++ , command(), target.address().to_string().c_str(), target.port());
+++
+++ m_server_connection.open(target.protocol());
+++ m_server_connection.async_connect(target
+++ , std::bind(&socks_connection::on_connected, shared_from_this()
+++ , std::placeholders::_1));
+++ }
+++
+++ void socks_connection::bind_connection(const asio::ip::tcp::endpoint& target)
+++ {
+++ std::printf("socks_connection::bind_connection(%s): binding to %s port %d\n"
+++ , command(), target.address().to_string().c_str(), target.port());
+++
+++ error_code ec;
+++ m_bind_socket.open(target.protocol(), ec);
+++ if (ec)
+++ {
+++ std::printf("ERROR: open bind socket failed: (%d) %s\n", ec.value()
+++ , ec.message().c_str());
+++ }
+++ else
+++ {
+++ m_bind_socket.bind(target, ec);
+++ }
+++
+++ int const response = ec
+++ ? (m_version == 4 ? 91 : 1)
+++ : (m_version == 4 ? 90 : 0);
+++ tcp::endpoint ep = m_bind_socket.local_endpoint();
+++ int const len = format_response(ep.address(), ep.port(), response);
+++
+++ if (ec)
+++ {
+++ std::printf("ERROR: binding socket to %s %d failed: (%d) %s\n"
+++ , target.address().to_string().c_str()
+++ , target.port()
+++ , ec.value()
+++ , ec.message().c_str());
+++
+++ auto self = shared_from_this();
+++
+++ asio::async_write(m_client_connection
+++ , asio::buffer(&m_in_buffer[0], len)
+++ , [=](boost::system::error_code const&, size_t)
+++ {
+++ self->close_connection();
+++ });
+++ return;
+++ }
+++
+++ // send response
+++ asio::async_write(m_client_connection
+++ , asio::buffer(&m_in_buffer[0], len)
+++ , std::bind(&socks_connection::start_accept, shared_from_this(), std::placeholders::_1));
+++ }
+++
+++ void socks_connection::udp_associate(const asio::ip::tcp::endpoint& target)
+++ {
+++ std::printf("socks_connection::udp_associate(%s): %s:%d\n"
+++ , command(), target.address().to_string().c_str(), target.port());
+++
+++ m_udp_associate_ep.address(target.address());
+++ m_udp_associate_ep.port(target.port());
+++
+++ error_code ec;
+++ m_udp_associate.open(m_udp_associate_ep.protocol(), ec);
+++ if (ec)
+++ {
+++ std::printf("ERROR: open UDP associate socket failed: (%d) %s\n", ec.value()
+++ , ec.message().c_str());
+++ }
+++ else
+++ {
+++ m_udp_associate.bind(udp::endpoint(address_v4(), std::uint16_t(m_bind_port++)), ec);
+++ if (ec)
+++ {
+++ std::printf("ERROR: binding socket failed: (%d) %s\n"
+++ , ec.value(), ec.message().c_str());
+++ }
+++ else
+++ {
+++ m_udp_associate.non_blocking(true);
+++ m_udp_associate.async_receive_from(boost::asio::buffer(m_udp_buffer)
+++ , m_udp_from, 0, std::bind(&socks_connection::on_read_udp, this, std::placeholders::_1, std::placeholders::_2));
+++ }
+++ }
+++
+++ int const response = ec ? 1 : 0;
+++ udp::endpoint ep = m_udp_associate.local_bound_to();
+++ int const len = (m_flags & udp_associate_respond_empty_hostname)
+++ ? format_hostname_response("foobar", ep.port(), response)
+++ : format_response(ep.address(), ep.port(), response);
+++
+++ if (ec)
+++ {
+++ auto self = shared_from_this();
+++
+++ asio::async_write(m_client_connection
+++ , asio::buffer(&m_in_buffer[0], len)
+++ , [=](boost::system::error_code const&, size_t)
+++ {
+++ self->close_connection();
+++ });
+++ return;
+++ }
+++
+++ // send response
+++ asio::async_write(m_client_connection, asio::buffer(&m_in_buffer[0], len)
+++ , std::bind(&socks_connection::wait_for_eof, shared_from_this(), std::placeholders::_1, std::placeholders::_2));
+++ }
+++
+++ void socks_connection::wait_for_eof(boost::system::error_code const& ec, std::size_t)
+++ {
+++ if (ec)
+++ {
+++ std::printf("socks_connection::wait_for_eof: %s\n", ec.message().c_str());
+++ m_udp_associate.close();
+++ m_udp_associate_ep = udp::endpoint();
+++ m_client_connection.close();
+++ return;
+++ }
+++
+++ if (m_flags & socks_flag::disconnect_udp_associate)
+++ {
+++ std::printf("socks_connection::wait_for_eof: closing connection prematurely\n");
+++ m_client_connection.close();
+++ return;
+++ }
+++
+++ m_client_connection.async_read_some(
+++ asio::buffer(m_out_buffer)
+++ , std::bind(&socks_connection::wait_for_eof, shared_from_this()
+++ , std::placeholders::_1, std::placeholders::_2));
+++ }
+++
+++ void socks_connection::on_read_udp(boost::system::error_code const& ec
+++ , std::size_t bytes_transferred)
+++ {
+++ std::printf("socks_connection::on_read_udp\n");
+++ if (ec)
+++ {
+++ std::printf("socks_connection::on_read_udp: %s\n", ec.message().c_str());
+++ return;
+++ }
+++
+++ // if the client didn't specify an IP and port it would send packets from,
+++ // we assumed the same IP as the TCP connection and assume the port is the
+++ // same as the first UDP packet from that host
+++ if (m_udp_associate_ep.port() == 0
+++ && m_udp_from.address() == m_udp_associate_ep.address())
+++ {
+++ m_udp_associate_ep.port(m_udp_from.port());
+++ }
+++
+++ if (m_udp_from == m_udp_associate_ep)
+++ {
+++ // read UDP ASSICOATE header and forward outgoing packet
+++ // +----+------+------+----------+----------+----------+
+++ // |RSV | FRAG | ATYP | DST.ADDR | DST.PORT | DATA |
+++ // +----+------+------+----------+----------+----------+
+++ // | 2 | 1 | 1 | Variable | 2 | Variable |
+++ // +----+------+------+----------+----------+----------+
+++
+++ char const* buf = m_udp_buffer.data();
+++ if (buf[2] != 0) std::printf("fragment != 0, not supported\n");
+++
+++ int const atyp = buf[3];
+++ if (atyp == 3)
+++ {
+++ // hostname
+++ int const len = buf[4];
+++
+++ buf += 5;
+++ bytes_transferred -= 5;
+++ std::string const hostname(buf, len);
+++ buf += len;
+++ bytes_transferred -= len;
+++
+++ std::uint16_t port = buf[0] & 0xff;
+++ port <<= 8;
+++ port |= buf[1] & 0xff;
+++ buf += 2;
+++ bytes_transferred -= 2;
+++
+++ auto it = m_name_mapping.right.find(hostname);
+++ if (it != m_name_mapping.right.end())
+++ {
+++ error_code err;
+++ m_udp_associate.send_to(boost::asio::buffer(buf, bytes_transferred)
+++ , udp::endpoint(it->second, port), 0, err);
+++ if (err) std::printf("send_to failed: %s\n", err.message().c_str());
+++ return;
+++ }
+++
+++ std::vector<char> forward_buffer(buf, buf + bytes_transferred);
+++
+++ m_udp_resolver.async_resolve(hostname.c_str(), std::to_string(port).c_str()
+++ , [buf=std::move(forward_buffer), hostname, this]
+++ (error_code const& ec, asio::ip::udp::resolver::results_type ips)
+++ {
+++ if (ec)
+++ {
+++ std::printf("resolve failed: %s\n", ec.message().c_str());
+++ return;
+++ }
+++
+++ for (auto const& ip : ips)
+++ {
+++ auto const target = ip.endpoint();
+++ error_code err;
+++ m_udp_associate.send_to(boost::asio::buffer(buf)
+++ , target, 0, err);
+++ if (!err)
+++ {
+++ m_name_mapping.insert({target.address(), hostname});
+++ break;
+++ }
+++ std::printf("send_to failed: %s\n", err.message().c_str());
+++ }
+++ });
+++ }
+++ else if (atyp == 1)
+++ {
+++ // IPv4
+++ std::uint32_t addr = buf[4] & 0xff;
+++ addr <<= 8;
+++ addr |= buf[5] & 0xff;
+++ addr <<= 8;
+++ addr |= buf[6] & 0xff;
+++ addr <<= 8;
+++ addr |= buf[7] & 0xff;
+++
+++ std::uint16_t port = buf[8] & 0xff;
+++ port <<= 8;
+++ port |= buf[9] & 0xff;
+++
+++ buf += 10;
+++ bytes_transferred -= 10;
+++
+++ asio::ip::udp::endpoint const target(address_v4(addr), port);
+++
+++ error_code err;
+++ m_udp_associate.send_to(boost::asio::buffer(buf, bytes_transferred), target, 0, err);
+++ if (err) std::printf("send_to failed: %s\n", err.message().c_str());
+++ }
+++ else
+++ {
+++ std::printf("only supports IPv4 and hostname. ATYP: %d\n", atyp);
+++ }
+++ }
+++ else
+++ {
+++ std::uint16_t const from_port = m_udp_from.port();
+++
+++ auto it = m_name_mapping.left.find(m_udp_from.address());
+++ if (it != m_name_mapping.left.end())
+++ {
+++ std::vector<char> header(7 + it->second.size());
+++ header[0] = 0; // RSV
+++ header[1] = 0;
+++ header[2] = 0; // fragment
+++ header[3] = 3; // ATYP
+++ header[4] = static_cast<char>(it->second.size());
+++ int idx = 5;
+++ std::copy(it->second.begin(), it->second.end(), header.data() + idx);
+++ idx += static_cast<int>(it->second.size());
+++ header[idx] = (from_port >> 8) & 0xff;
+++ header[idx + 1] = from_port & 0xff;
+++
+++ std::array<boost::asio::const_buffer, 2> vec{{
+++ {header.data(), header.size()},
+++ {m_udp_buffer.data(), bytes_transferred}}};
+++
+++ error_code err;
+++ m_udp_associate.send_to(vec, m_udp_associate_ep, 0, err);
+++ if (err) std::printf("send_to failed: %s\n", err.message().c_str());
+++ }
+++ else
+++ {
+++ // add UDP ASSOCIATE header and forward to client
+++ std::uint32_t const from_addr = m_udp_from.address().to_v4().to_uint();
+++ std::array<char, 10> header;
+++ header[0] = 0; // RSV
+++ header[1] = 0;
+++ header[2] = 0; // fragment
+++ header[3] = 1; // ATYP
+++ header[4] = (from_addr >> 24) & 0xff; // Address
+++ header[5] = (from_addr >> 16) & 0xff;
+++ header[6] = (from_addr >> 8) & 0xff;
+++ header[7] = (from_addr) & 0xff;
+++ header[8] = (from_port >> 8) & 0xff;
+++ header[9] = from_port & 0xff;
+++
+++ std::array<boost::asio::const_buffer, 2> vec{{
+++ {header.data(), header.size()},
+++ {m_udp_buffer.data(), bytes_transferred}}};
+++
+++ error_code err;
+++ m_udp_associate.send_to(vec, m_udp_associate_ep, 0, err);
+++ if (err) std::printf("send_to failed: %s\n", err.message().c_str());
+++ }
+++ }
+++
+++ m_udp_associate.async_receive_from(boost::asio::buffer(m_udp_buffer)
+++ , m_udp_from, 0, std::bind(&socks_connection::on_read_udp, this, std::placeholders::_1, std::placeholders::_2));
+++ }
+++
+++ void socks_connection::start_accept(boost::system::error_code const& ec)
+++ {
+++ if (ec)
+++ {
+++ std::printf("socks_connection(%s): error writing to client: (%d) %s\n"
+++ , command(), ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++ m_bind_socket.listen();
+++ m_bind_socket.async_accept(m_server_connection
+++ , std::bind(&socks_connection::on_connected
+++ , shared_from_this(), std::placeholders::_1));
+++
+++ m_client_connection.async_read_some(
+++ sim::asio::buffer(m_out_buffer)
+++ , std::bind(&socks_connection::on_client_receive, shared_from_this()
+++ , std::placeholders::_1, std::placeholders::_2));
+++ }
+++
+++ int socks_connection::format_response(address const& addr, int const port
+++ , int const response)
+++ {
+++ int i = 0;
+++ if (m_version == 5)
+++ {
+++// +----+-----+-------+------+----------+----------+
+++// |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT |
+++// +----+-----+-------+------+----------+----------+
+++// | 1 | 1 | X'00' | 1 | Variable | 2 |
+++// +----+-----+-------+------+----------+----------+
+++
+++ m_in_buffer[i++] = char(m_version); // version
+++ m_in_buffer[i++] = char(response); // response
+++ m_in_buffer[i++] = 0; // reserved
+++ if (addr.is_v4())
+++ {
+++ m_in_buffer[i++] = 1; // IPv4
+++ address_v4::bytes_type b = addr.to_v4().to_bytes();
+++ memcpy(&m_in_buffer[i], &b[0], b.size());
+++ i += int(b.size());
+++ } else {
+++ m_in_buffer[i++] = 4; // IPv6
+++ address_v6::bytes_type b = addr.to_v6().to_bytes();
+++ memcpy(&m_in_buffer[i], &b[0], b.size());
+++ i += int(b.size());
+++ }
+++
+++ m_in_buffer[i++] = (port >> 8) & 0xff;
+++ m_in_buffer[i++] = port & 0xff;
+++ }
+++ else
+++ {
+++ m_in_buffer[i++] = 0; // response version
+++ m_in_buffer[i++] = char(response); // return code
+++
+++ assert(addr.is_v4());
+++
+++ m_in_buffer[i++] = (port >> 8) & 0xff;
+++ m_in_buffer[i++] = port & 0xff;
+++
+++ address_v4::bytes_type b = addr.to_v4().to_bytes();
+++ memcpy(&m_in_buffer[i], &b[0], b.size());
+++ i += int(b.size());
+++ }
+++ return i;
+++ }
+++
+++ int socks_connection::format_hostname_response(char const* hostname, int const port
+++ , int const response)
+++ {
+++ int i = 0;
+++ if (m_version != 5)
+++ {
+++ std::printf("socks_connection: hostname response requires SOCKS v5\n");
+++ close_connection();
+++ return 0;
+++ }
+++// +----+-----+-------+------+----------+----------+
+++// |VER | REP | RSV | ATYP | BND.ADDR | BND.PORT |
+++// +----+-----+-------+------+----------+----------+
+++// | 1 | 1 | X'00' | 1 | Variable | 2 |
+++// +----+-----+-------+------+----------+----------+
+++
+++ m_in_buffer[i++] = char(m_version); // version
+++ m_in_buffer[i++] = char(response); // response
+++ m_in_buffer[i++] = 0; // reserved
+++ m_in_buffer[i++] = 3; // DOMAINNAME
+++ m_in_buffer[i++] = std::uint8_t(::strlen(hostname));
+++ for (; *hostname != '\0'; ++hostname)
+++ m_in_buffer[i++] = *hostname;
+++
+++ m_in_buffer[i++] = (port >> 8) & 0xff;
+++ m_in_buffer[i++] = port & 0xff;
+++ return i;
+++ }
+++
+++ void socks_connection::on_connected(boost::system::error_code const& ec)
+++ {
+++ std::printf("socks_connection(%s): on_connect: (%d) %s\n"
+++ , command(), ec.value(), ec.message().c_str());
+++
+++ if (ec == asio::error::operation_aborted
+++ || ec == boost::system::errc::bad_file_descriptor)
+++ {
+++ return;
+++ }
+++
+++ boost::system::error_code err;
+++ asio::ip::tcp::endpoint const ep = m_server_connection.remote_endpoint(err);
+++ if (!err)
+++ {
+++ std::printf("socks_connection(%s): remote_endpoint: %s %d\n"
+++ , command(), ep.address().to_string().c_str(), ep.port());
+++ }
+++
+++ int const response = ec
+++ ? (m_version == 4 ? 91 : 5)
+++ : (m_version == 4 ? 90 : 0);
+++ int const len = format_response(ep.address(), ep.port(), response);
+++
+++ if (ec)
+++ {
+++ std::printf("socks_connection(%s): failed to connect to/accept from target server: (%d) %s\n"
+++ , command(), ec.value(), ec.message().c_str());
+++
+++ auto self = shared_from_this();
+++
+++ asio::async_write(m_client_connection
+++ , asio::buffer(&m_in_buffer[0], len)
+++ , [=](boost::system::error_code const&, size_t)
+++ {
+++ self->close_connection();
+++ });
+++ return;
+++ }
+++
+++ auto self = shared_from_this();
+++
+++ asio::async_write(m_client_connection
+++ , asio::buffer(&m_in_buffer[0], len)
+++ , [this, self](boost::system::error_code const& ec, size_t)
+++ {
+++ if (ec)
+++ {
+++ std::printf("socks_connection(%s): error writing to client: (%d) %s\n"
+++ , command(), ec.value(), ec.message().c_str());
+++ return;
+++ }
+++
+++ // read from the client and from the server
+++ self->m_server_connection.async_read_some(
+++ sim::asio::buffer(m_in_buffer)
+++ , std::bind(&socks_connection::on_server_receive, self
+++ , std::placeholders::_1, std::placeholders::_2));
+++ self->m_client_connection.async_read_some(
+++ sim::asio::buffer(m_out_buffer)
+++ , std::bind(&socks_connection::on_client_receive, self
+++ , std::placeholders::_1, std::placeholders::_2));
+++ });
+++ }
+++
+++ // we received some data from the client, forward it to the server
+++ void socks_connection::on_client_receive(boost::system::error_code const& ec
+++ , std::size_t bytes_transferred)
+++ {
+++ // bad file descriptor means the socket has been closed. Whoever closed
+++ // the socket will have opened a new one, we cannot call
+++ // close_connection()
+++ if (ec == asio::error::operation_aborted
+++ || ec == boost::system::errc::bad_file_descriptor)
+++ return;
+++
+++ if (ec)
+++ {
+++ std::printf("socks_connection (%s): error reading from client: (%d) %s\n"
+++ , command(), ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++ asio::async_write(m_server_connection, asio::buffer(&m_out_buffer[0], bytes_transferred)
+++ , std::bind(&socks_connection::on_client_forward, shared_from_this()
+++ , std::placeholders::_1, std::placeholders::_2));
+++ }
+++
+++ void socks_connection::on_client_forward(error_code const& ec
+++ , size_t /* bytes_transferred */)
+++ {
+++ if (ec)
+++ {
+++ std::printf("socks_connection(%s): error writing to server: (%d) %s\n"
+++ , command(), ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++ m_client_connection.async_read_some(
+++ sim::asio::buffer(m_out_buffer)
+++ , std::bind(&socks_connection::on_client_receive, shared_from_this()
+++ , std::placeholders::_1, std::placeholders::_2));
+++ }
+++
+++ // we received some data from the server, forward it to the server
+++ void socks_connection::on_server_receive(boost::system::error_code const& ec
+++ , std::size_t bytes_transferred)
+++ {
+++ if (ec)
+++ {
+++ std::printf("socks_connection(%s): error reading from server: (%d) %s\n"
+++ , command(), ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++ asio::async_write(m_client_connection, asio::buffer(&m_in_buffer[0], bytes_transferred)
+++ , std::bind(&socks_connection::on_server_forward, shared_from_this()
+++ , std::placeholders::_1, std::placeholders::_2));
+++ }
+++
+++ void socks_connection::on_server_forward(error_code const& ec
+++ , size_t /* bytes_transferred */)
+++ {
+++ if (ec)
+++ {
+++ std::printf("socks_connection(%s): error writing to client: (%d) %s\n"
+++ , command(), ec.value(), ec.message().c_str());
+++ close_connection();
+++ return;
+++ }
+++
+++ m_server_connection.async_read_some(
+++ sim::asio::buffer(m_in_buffer)
+++ , std::bind(&socks_connection::on_server_receive, shared_from_this()
+++ , std::placeholders::_1, std::placeholders::_2));
+++ }
+++
+++ void socks_connection::close_connection()
+++ {
+++ error_code err;
+++ m_client_connection.close(err);
+++ if (err)
+++ {
+++ std::printf("socks_connection::close: failed to close client connection (%d) %s\n"
+++ , err.value(), err.message().c_str());
+++ }
+++ m_server_connection.close(err);
+++ if (err)
+++ {
+++ std::printf("socks_connection::close: failed to close server connection (%d) %s\n"
+++ , err.value(), err.message().c_str());
+++ }
+++
+++ m_bind_socket.close(err);
+++ if (err)
+++ {
+++ std::printf("socks_connection::close: failed to close bind socket (%d) %s\n"
+++ , err.value(), err.message().c_str());
+++ }
+++ }
+++
+++ char const* socks_connection::command() const
+++ {
+++ switch (m_command)
+++ {
+++ case 1: return "CONNECT";
+++ case 2: return "BIND";
+++ case 3: return "UDP_ASSOCIATE";
+++ default: return "UNKNOWN";
+++ }
+++ }
+++}
+++
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/tcp_socket.cpp
++@@ -0,0 +1,929 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include "simulator/packet.hpp"
+++#include "simulator/pcap.hpp"
+++#include "simulator/handler_allocator.hpp"
+++
+++#include <functional>
+++#include <cinttypes>
+++#include <cstdio> // for printf
+++
+++#include "simulator/push_warnings.hpp"
+++#include <boost/system/error_code.hpp>
+++#include <boost/function.hpp>
+++#include "simulator/pop_warnings.hpp"
+++
+++typedef sim::chrono::high_resolution_clock::time_point time_point;
+++typedef sim::chrono::high_resolution_clock::duration duration;
+++
+++using namespace std::placeholders;
+++
+++namespace sim {
+++namespace asio {
+++namespace ip {
+++
+++ tcp::socket::socket(io_context& ios)
+++ : socket_base(ios)
+++ , m_connect_timer(ios)
+++ , m_recv_timer(ios)
+++ {}
+++
+++ tcp::socket::socket(socket&& s)
+++ : socket_base(std::move(s))
+++ , m_connect_handler(std::move(s.m_connect_handler))
+++ , m_connect_timer(std::move(s.m_connect_timer))
+++ , m_mss(s.m_mss)
+++ , m_send_handler(std::move(s.m_send_handler))
+++ , m_wait_send_handler(std::move(s.m_wait_send_handler))
+++ , m_send_buffer(std::move(s.m_send_buffer))
+++ , m_incoming_queue(std::move(s.m_incoming_queue))
+++ , m_queue_size(std::move(s.m_queue_size))
+++ , m_recv_handler(std::move(s.m_recv_handler))
+++ , m_wait_recv_handler(std::move(s.m_wait_recv_handler))
+++ , m_recv_buffer(std::move(s.m_recv_buffer))
+++ , m_recv_timer(std::move(s.m_recv_timer))
+++ , m_is_v4(std::move(s.m_is_v4))
+++ , m_recv_null_buffers(std::move(s.m_recv_null_buffers))
+++ , m_send_null_buffers(std::move(s.m_send_null_buffers))
+++ , m_channel(std::move(s.m_channel))
+++ , m_next_outgoing_seq(std::move(s.m_next_outgoing_seq))
+++ , m_next_incoming_seq(std::move(s.m_next_incoming_seq))
+++ , m_last_drop_seq(std::move(s.m_last_drop_seq))
+++ , m_cwnd(std::move(s.m_cwnd))
+++ , m_bytes_in_flight(std::move(s.m_bytes_in_flight))
+++ , m_reorder_buffer(std::move(s.m_reorder_buffer))
+++ , m_outstanding_packet_sizes(std::move(s.m_outstanding_packet_sizes))
+++ , m_outgoing_packets(std::move(s.m_outgoing_packets))
+++ {
+++ if (m_forwarder) m_forwarder->reset(this);
+++ s.m_forwarder.reset();
+++ s.m_open = false;
+++ s.m_bound_to = ip::tcp::endpoint();
+++
+++ if (m_bound_to != ip::tcp::endpoint())
+++ m_io_service.rebind_socket(&s, this, m_bound_to);
+++ }
+++
+++ tcp::socket::~socket()
+++ {
+++ boost::system::error_code ec;
+++
+++ m_channel.reset();
+++
+++ if (m_bound_to != ip::tcp::endpoint())
+++ {
+++ m_io_service.unbind_socket(this, m_bound_to);
+++ m_bound_to = ip::tcp::endpoint();
+++ m_user_bound_to = ip::tcp::endpoint();
+++ }
+++ m_open = false;
+++
+++ // prevent any more packets from being delivered to this socket
+++ if (m_forwarder)
+++ {
+++ m_forwarder->reset();
+++ m_forwarder.reset();
+++ }
+++ cancel(ec);
+++ }
+++
+++ void tcp::socket::open(tcp protocol, boost::system::error_code& ec) try
+++ {
+++ close(ec);
+++ m_open = true;
+++ m_is_v4 = (protocol == ip::tcp::v4());
+++ ec.clear();
+++ m_forwarder = std::make_shared<aux::sink_forwarder>(this);
+++ }
+++ catch (std::bad_alloc const&)
+++ {
+++ ec = make_error_code(boost::system::errc::not_enough_memory);
+++ }
+++ catch (boost::system::system_error const& err)
+++ {
+++ ec = err.code();
+++ }
+++
+++ void tcp::socket::open(tcp protocol)
+++ {
+++ boost::system::error_code ec;
+++ open(protocol, ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ }
+++
+++ // used to attach an incoming connection to this
+++ void tcp::socket::internal_connect(tcp::endpoint const& bind_ip
+++ , std::shared_ptr<aux::channel> const& c
+++ , boost::system::error_code& ec)
+++ {
+++ open(m_is_v4 ? tcp::v4() : tcp::v6(), ec);
+++ if (ec)
+++ {
+++ std::printf("tcp::socket::internal_connect() error: (%d) %s\n"
+++ , ec.value(), ec.message().c_str());
+++ return;
+++ }
+++ m_bound_to = bind_ip;
+++ m_user_bound_to = bind_ip;
+++ m_channel = c;
+++ assert(m_forwarder);
+++ c->hops[1].replace_last(m_forwarder);
+++ }
+++
+++ void tcp::socket::bind(ip::tcp::endpoint const& ep
+++ , boost::system::error_code& ec) try
+++ {
+++ if (!m_open)
+++ {
+++ ec = error::bad_descriptor;
+++ return;
+++ }
+++
+++ if (ep.address().is_v4() != m_is_v4)
+++ {
+++ ec = error::address_family_not_supported;
+++ return;
+++ }
+++
+++ ip::tcp::endpoint addr = m_io_service.bind_socket(this, ep, ec);
+++ if (ec) return;
+++ m_bound_to = addr;
+++ m_user_bound_to = addr;
+++ }
+++ catch (std::bad_alloc const&)
+++ {
+++ ec = make_error_code(boost::system::errc::not_enough_memory);
+++ }
+++ catch (boost::system::system_error const& err)
+++ {
+++ ec = err.code();
+++ }
+++
+++ void tcp::socket::bind(ip::tcp::endpoint const& ep)
+++ {
+++ boost::system::error_code ec;
+++ bind(ep, ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ }
+++
+++ void tcp::socket::close()
+++ {
+++ boost::system::error_code ec;
+++ close(ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ }
+++
+++ void tcp::socket::close(boost::system::error_code& ec) try
+++ {
+++ if (m_channel)
+++ {
+++ int const remote = m_channel->remote_idx(m_bound_to);
+++ route hops = m_channel->hops[remote];
+++
+++ // if m_connect_handler is still set, it means the connection hasn't
+++ // been established yet, and this channel points to the acceptor
+++ // socket, not another open TCP connection.
+++ if (!hops.empty() && !m_connect_handler)
+++ {
+++ aux::packet p;
+++ p.type = aux::packet::type_t::error;
+++ p.ec = asio::error::eof;
+++ p.from = asio::ip::udp::endpoint(
+++ m_bound_to.address(), m_bound_to.port());
+++ p.overhead = 40;
+++ p.hops = hops;
+++ p.seq_nr = m_next_outgoing_seq++;
+++ send_packet(std::move(p));
+++ }
+++ m_channel.reset();
+++ }
+++
+++ if (m_bound_to != ip::tcp::endpoint())
+++ {
+++ m_io_service.unbind_socket(this, m_bound_to);
+++ m_bound_to = ip::tcp::endpoint();
+++ m_user_bound_to = ip::tcp::endpoint();
+++ }
+++ m_open = false;
+++
+++ // prevent any more packets from being delivered to this socket
+++ if (m_forwarder)
+++ {
+++ m_forwarder->reset();
+++ m_forwarder.reset();
+++ }
+++
+++ // reset socket state
+++ m_queue_size = 0;
+++ m_mss = 1475;
+++ m_cwnd = m_mss * 2;
+++ m_bytes_in_flight = 0;
+++ m_outstanding_packet_sizes.clear();
+++ m_recv_null_buffers = false;
+++ m_send_null_buffers = false;
+++ m_next_incoming_seq = 0;
+++ m_next_outgoing_seq = 0;
+++ m_last_drop_seq = 0;
+++
+++ cancel(ec);
+++
+++ ec.clear();
+++ }
+++ catch (std::bad_alloc const&)
+++ {
+++ ec = make_error_code(boost::system::errc::not_enough_memory);
+++ }
+++ catch (boost::system::system_error const& err)
+++ {
+++ ec = err.code();
+++ }
+++
+++ std::size_t tcp::socket::available(boost::system::error_code& ec) const
+++ {
+++ if (!m_open)
+++ {
+++ ec = boost::system::error_code(error::bad_descriptor);
+++ return 0;
+++ }
+++ if (!m_channel)
+++ {
+++ ec = boost::system::error_code(error::not_connected);
+++ return 0;
+++ }
+++ if (m_incoming_queue.empty())
+++ {
+++ return 0;
+++ }
+++
+++ std::size_t ret = 0;
+++ for (aux::packet const& p : m_incoming_queue)
+++ {
+++ if (p.type == aux::packet::type_t::error)
+++ {
+++ if (ret > 0) return ret;
+++
+++ // if the read buffer is drained and there is an error, report that
+++ // error.
+++ ec = p.ec;
+++ return 0;
+++ }
+++ ret += p.buffer.size();
+++ }
+++ return ret;
+++ }
+++
+++ std::size_t tcp::socket::available() const
+++ {
+++ boost::system::error_code ec;
+++ std::size_t ret = available(ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ return ret;
+++ }
+++
+++ void tcp::socket::cancel(boost::system::error_code&)
+++ {
+++ abort_recv_handlers();
+++ abort_send_handlers();
+++
+++ if (m_connect_handler)
+++ {
+++ post(m_io_service, aux::make_malloc(std::bind(std::move(m_connect_handler)
+++ , boost::system::error_code(error::operation_aborted))));
+++ m_connect_handler = nullptr;
+++ }
+++ }
+++
+++ void tcp::socket::cancel()
+++ {
+++ boost::system::error_code ec;
+++ cancel(ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ }
+++
+++ tcp::endpoint tcp::socket::remote_endpoint(boost::system::error_code& ec) const
+++ {
+++ if (!m_open)
+++ {
+++ ec = error::bad_descriptor;
+++ return tcp::endpoint();
+++ }
+++
+++ if (!m_channel)
+++ {
+++ ec = error::not_connected;
+++ return tcp::endpoint();
+++ }
+++
+++ int const remote = m_channel->remote_idx(m_bound_to);
+++ return m_channel->visible_ep[remote];
+++ }
+++
+++ tcp::endpoint tcp::socket::remote_endpoint() const
+++ {
+++ boost::system::error_code ec;
+++ tcp::endpoint ret = remote_endpoint(ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ return ret;
+++ }
+++
+++ void tcp::socket::async_connect(tcp::endpoint const& target
+++ , aux::function<void(boost::system::error_code const&)> h)
+++ {
+++ if (!m_open) open(target.protocol());
+++
+++ assert(h);
+++ assert(!m_connect_handler);
+++
+++ // find remote socket
+++ boost::system::error_code ec;
+++ if (m_bound_to.address() == ip::address())
+++ {
+++ auto endpoint = ip::tcp::endpoint();
+++ if (target.address().is_v4()) {
+++ endpoint.address(ip::address_v4::any());
+++ } else {
+++ endpoint.address(ip::address_v6::any());
+++ }
+++ ip::tcp::endpoint addr = m_io_service.bind_socket(this
+++ , endpoint, ec);
+++ if (ec)
+++ {
+++ post(m_io_service, aux::make_malloc(std::bind(std::move(h), ec)));
+++ return;
+++ }
+++ m_bound_to = addr;
+++ m_user_bound_to = addr;
+++ }
+++ if (m_bound_to.address().is_v4() != target.address().is_v4())
+++ {
+++ post(m_io_service, aux::make_malloc(std::bind(std::move(h),
+++ boost::system::error_code(error::address_family_not_supported))));
+++ return;
+++ }
+++ m_channel = m_io_service.internal_connect(this, target, ec);
+++ m_mss = m_io_service.get_path_mtu(m_bound_to.address(), target.address());
+++ m_cwnd = m_mss * 2;
+++ if (ec)
+++ {
+++ m_channel.reset();
+++ // TODO: ask the policy object what the round-trip to this endpoint is
+++ m_connect_timer.expires_after(chrono::milliseconds(50));
+++ m_connect_timer.async_wait(aux::make_malloc(std::bind(std::move(h), ec)));
+++ return;
+++ }
+++
+++ m_connect_handler = std::move(h);
+++
+++ // the acceptor socket will call internal_connect_complete once the
+++ // connection is established
+++ }
+++
+++ void tcp::socket::abort_recv_handlers()
+++ {
+++ if (m_recv_handler) post(m_io_service, aux::make_malloc(std::bind(std::move(m_recv_handler)
+++ , boost::system::error_code(error::operation_aborted), std::size_t(0))));
+++
+++ if (m_wait_recv_handler) post(m_io_service, aux::make_malloc(std::bind(std::move(m_wait_recv_handler)
+++ , boost::system::error_code(error::operation_aborted))));
+++
+++ m_recv_timer.cancel();
+++ m_recv_handler = nullptr;
+++ m_wait_recv_handler = nullptr;
+++ m_recv_buffer.clear();
+++ m_recv_null_buffers = false;
+++ }
+++
+++ void tcp::socket::abort_send_handlers()
+++ {
+++ if (m_send_handler) post(m_io_service, aux::make_malloc(std::bind(std::move(m_send_handler)
+++ , boost::system::error_code(error::operation_aborted), std::size_t(0))));
+++
+++ if (m_wait_send_handler) post(m_io_service, aux::make_malloc(std::bind(std::move(m_wait_send_handler)
+++ , boost::system::error_code(error::operation_aborted))));
+++
+++ m_send_handler = nullptr;
+++ m_wait_send_handler = nullptr;
+++ m_send_buffer.clear();
+++ m_send_null_buffers = false;
+++ }
+++
+++ void tcp::socket::async_write_some_impl(std::vector<boost::asio::const_buffer> const& bufs
+++ , aux::function<void(boost::system::error_code const&, std::size_t)> handler)
+++ {
+++ boost::system::error_code ec;
+++ std::size_t const bytes_transferred = write_some_impl(bufs, ec);
+++ if (ec == boost::system::error_code(error::would_block))
+++ {
+++ m_send_handler = std::move(handler);
+++ m_send_buffer = bufs;
+++ return;
+++ }
+++
+++ if (ec)
+++ {
+++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec, std::size_t(0))));
+++ m_send_handler = nullptr;
+++ m_send_buffer.clear();
+++ return;
+++ }
+++
+++ boost::system::error_code no_error;
+++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), no_error
+++ , bytes_transferred)));
+++ m_send_handler = nullptr;
+++ m_send_buffer.clear();
+++ }
+++
+++ std::size_t tcp::socket::write_some_impl(
+++ std::vector<boost::asio::const_buffer> const& bufs
+++ , boost::system::error_code& ec)
+++ {
+++ if (!m_open)
+++ {
+++ ec = boost::system::error_code(error::bad_descriptor);
+++ return 0;
+++ }
+++ if (!m_channel)
+++ {
+++ ec = boost::system::error_code(error::not_connected);
+++ return 0;
+++ }
+++
+++ // the connect handler is used as proxy that this socket has not competed
+++ // the connection yet. We're still waiting for SYN+ACK
+++ if (m_connect_handler)
+++ {
+++ ec = boost::system::error_code(error::would_block);
+++ return 0;
+++ }
+++
+++ int const remote = m_channel->remote_idx(m_bound_to);
+++ route hops = m_channel->hops[remote];
+++ if (hops.empty())
+++ {
+++ ec = boost::system::error_code(error::not_connected);
+++ return 0;
+++ }
+++
+++ if (m_bytes_in_flight + m_mss > m_cwnd)
+++ {
+++ // this indicates that the send buffer is very large, we should
+++ // probably not be able to stuff more bytes down it
+++ // wait for the receiving end to pop some bytes off
+++ ec = boost::system::error_code(error::would_block);
+++ return 0;
+++ }
+++
+++ std::size_t ret = 0;
+++
+++ for (auto const& buf : bufs)
+++ {
+++ // split up in packets
+++ int buf_size = int(buf.size());
+++ std::uint8_t const* ptr = static_cast<std::uint8_t const*>(buf.data());
+++ while (buf_size > 0)
+++ {
+++ int packet_size = (std::min)(buf_size, m_mss);
+++ aux::packet p;
+++ p.type = aux::packet::type_t::payload;
+++ p.buffer.assign(ptr, ptr + packet_size);
+++ p.from = asio::ip::udp::endpoint(
+++ m_bound_to.address(), m_bound_to.port());
+++ p.overhead = 40;
+++ p.hops = hops;
+++ p.seq_nr = m_next_outgoing_seq++;
+++ p.drop_fun = std::bind(&tcp::socket::packet_dropped, this, _1);
+++
+++ send_packet(std::move(p));
+++ ptr += packet_size;
+++ buf_size -= packet_size;
+++ ret += packet_size;
+++
+++ if (m_bytes_in_flight + m_mss > m_cwnd)
+++ {
+++ // the congestion window is full
+++ if (ret == 0)
+++ {
+++ ec = boost::system::error_code(error::would_block);
+++ return 0;
+++ }
+++
+++ return ret;
+++ }
+++ }
+++ }
+++
+++ return ret;
+++ }
+++
+++ std::size_t tcp::socket::read_some_impl(
+++ std::vector<boost::asio::mutable_buffer> const& bufs
+++ , boost::system::error_code& ec)
+++ {
+++ // a zero-sized read always completes immediately with 0 bytes;
+++ // boost.asio's SSL implementation relies on this to post a
+++ // completion handler without transferring any data.
+++ if (boost::asio::buffer_size(bufs) == 0)
+++ {
+++ ec.clear();
+++ return 0;
+++ }
+++
+++ assert(!bufs.empty());
+++ if (!m_open)
+++ {
+++ ec = boost::system::error_code(error::bad_descriptor);
+++ return 0;
+++ }
+++ if (!m_channel)
+++ {
+++ ec = boost::system::error_code(error::not_connected);
+++ return 0;
+++ }
+++ if (m_connect_handler)
+++ {
+++ // the socket is not done connecting yet
+++ ec = boost::system::error_code(error::would_block);
+++ return 0;
+++ }
+++
+++ if (m_incoming_queue.empty())
+++ {
+++ ec = boost::system::error_code(error::would_block);
+++ return 0;
+++ }
+++
+++ typedef std::vector<boost::asio::mutable_buffer> buffers_t;
+++ m_recv_buffer = bufs;
+++ buffers_t::iterator recv_iter = m_recv_buffer.begin();
+++ int total_received = 0;
+++ // the offset in the current receive buffer we're writing to. i.e. the
+++ // buffer recv_iter points to
+++ int buf_offset = 0;
+++
+++ while (!m_incoming_queue.empty())
+++ {
+++ aux::packet& p = m_incoming_queue.front();
+++
+++ if (p.type == aux::packet::type_t::error)
+++ {
+++ // if we have received bytes also, first deliver those. In the next
+++ // read, deliver the error
+++ if (total_received > 0) break;
+++
+++ assert(p.ec);
+++ ec = p.ec;
+++ m_incoming_queue.erase(m_incoming_queue.begin());
+++ m_channel.reset();
+++ return 0;
+++ }
+++ else if (p.type == aux::packet::type_t::payload)
+++ {
+++ // copy bytes from the incoming queue into the receive buffer.
+++ // both are vectors of buffer, so it can get a bit hairy
+++ while (recv_iter != m_recv_buffer.end())
+++ {
+++ int const buf_size = int(recv_iter->size());
+++ int const copy_size = (std::min)(int(p.buffer.size())
+++ , buf_size - buf_offset);
+++
+++ memcpy(static_cast<char*>(recv_iter->data()) + buf_offset
+++ , p.buffer.data(), copy_size);
+++
+++ p.buffer.erase(p.buffer.begin(), p.buffer.begin() + copy_size);
+++ m_queue_size -= copy_size;
+++
+++ buf_offset += copy_size;
+++ assert(buf_offset <= buf_size);
+++ total_received += copy_size;
+++ if (buf_offset == buf_size)
+++ {
+++ ++recv_iter;
+++ buf_offset = 0;
+++ }
+++
+++ if (p.buffer.empty())
+++ {
+++ m_incoming_queue.erase(m_incoming_queue.begin());
+++ break;
+++ }
+++ }
+++ }
+++ else
+++ {
+++ assert(false);
+++ }
+++
+++ if (recv_iter == m_recv_buffer.end())
+++ break;
+++ }
+++
+++ assert(total_received > 0);
+++
+++ ec.clear();
+++ return total_received;
+++ }
+++
+++ void tcp::socket::async_read_some_impl(std::vector<boost::asio::mutable_buffer> const& bufs
+++ , aux::function<void(boost::system::error_code const&, std::size_t)> handler)
+++ {
+++ // a zero-sized read always completes immediately with 0 bytes
+++ // transferred, regardless of connection or queue state. boost.asio's
+++ // SSL implementation relies on this to bounce a completion handler
+++ // through the executor without actually transferring any data.
+++ if (boost::asio::buffer_size(bufs) == 0)
+++ {
+++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler)
+++ , boost::system::error_code(), std::size_t(0))));
+++ return;
+++ }
+++
+++ assert(!bufs.empty());
+++
+++ boost::system::error_code ec;
+++ std::size_t bytes_transferred = read_some_impl(bufs, ec);
+++ if (ec == boost::system::error_code(error::would_block))
+++ {
+++ assert(m_incoming_queue.empty());
+++
+++ m_recv_buffer = bufs;
+++ m_recv_handler = std::move(handler);
+++ m_recv_null_buffers = false;
+++ return;
+++ }
+++
+++ if (ec)
+++ {
+++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec, std::size_t(0))));
+++ m_recv_handler = nullptr;
+++ m_recv_buffer.clear();
+++ return;
+++ }
+++
+++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec, bytes_transferred)));
+++ m_recv_handler = nullptr;
+++ m_recv_buffer.clear();
+++ }
+++
+++ void tcp::socket::async_wait_read_impl(
+++ aux::function<void(boost::system::error_code const&)> handler)
+++ {
+++ boost::system::error_code ec;
+++ // null_buffers notifies the handler when data is available, without
+++ // reading any
+++ int const bytes = int(available(ec));
+++ if (ec)
+++ {
+++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec)));
+++ m_recv_handler = nullptr;
+++ m_recv_buffer.clear();
+++ return;
+++ }
+++
+++ if (bytes > 0)
+++ {
+++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec)));
+++ m_recv_handler = nullptr;
+++ m_recv_buffer.clear();
+++ return;
+++ }
+++
+++ m_wait_recv_handler = std::move(handler);
+++ m_recv_null_buffers = true;
+++ }
+++
+++ void tcp::socket::async_wait_write_impl(
+++ aux::function<void(boost::system::error_code const&)> handler)
+++ {
+++ if (!m_open)
+++ {
+++ boost::system::error_code const ec(error::bad_descriptor);
+++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec)));
+++ return;
+++ }
+++
+++ if (!m_channel)
+++ {
+++ boost::system::error_code const ec(error::not_connected);
+++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec)));
+++ return;
+++ }
+++
+++ if (!m_connect_handler && m_bytes_in_flight + m_mss <= m_cwnd)
+++ {
+++ // the socket is writable right now. complete immediately without
+++ // actually writing anything, this is the null_buffers equivalent
+++ // for writes
+++ boost::system::error_code const ec;
+++ post(m_io_service, aux::make_malloc(std::bind(std::move(handler), ec)));
+++ return;
+++ }
+++
+++ m_wait_send_handler = std::move(handler);
+++ m_send_null_buffers = true;
+++ }
+++
+++ // if there is an outstanding read operation, and this was the first incoming
+++ // operation since we last drained, wake up the reader
+++ void tcp::socket::maybe_wakeup_reader()
+++ {
+++ if (m_incoming_queue.size() != 1 || (!m_recv_handler && !m_wait_recv_handler)) return;
+++
+++ if (m_recv_null_buffers)
+++ {
+++ async_wait_read_impl(std::move(m_wait_recv_handler));
+++ }
+++ else
+++ {
+++ // we have an async. read operation outstanding, and we just put one
+++ // packet in our incoming queue.
+++
+++ // try to read from it and potentially fire the handler
+++ async_read_some_impl(m_recv_buffer, std::move(m_recv_handler));
+++ }
+++ }
+++
+++ void tcp::socket::maybe_wakeup_writer()
+++ {
+++ if (!m_send_handler && !m_wait_send_handler) return;
+++
+++ if (m_send_null_buffers)
+++ {
+++ async_wait_write_impl(std::move(m_wait_send_handler));
+++ }
+++ else
+++ {
+++ // we have an async. write operation outstanding
+++ async_write_some_impl(m_send_buffer, std::move(m_send_handler));
+++ }
+++ }
+++
+++ bool tcp::socket::internal_is_listening() { return false; }
+++
+++ void tcp::socket::send_packet(aux::packet p)
+++ {
+++ m_bytes_in_flight += int(p.buffer.size());
+++ m_outstanding_packet_sizes[p.seq_nr] = int(p.buffer.size());
+++
+++ int const idx = m_channel->self_idx(m_bound_to);
+++ p.byte_counter = m_channel->bytes_sent[idx];
+++ m_channel->bytes_sent[idx] += std::uint32_t(p.buffer.size());
+++
+++ auto* log = m_io_service.sim().get_pcap();
+++ if (log)
+++ {
+++ int const remote = m_channel->remote_idx(m_bound_to);
+++ log->log_tcp(p, m_bound_to, m_channel->ep[remote]);
+++ }
+++
+++ forward_packet(std::move(p));
+++ }
+++
+++ void tcp::socket::packet_dropped(aux::packet p)
+++ {
+++ int remote = m_channel->remote_idx(m_bound_to);
+++ p.hops = m_channel->hops[remote];
+++ m_outgoing_packets.push_back(std::move(p));
+++
+++ const int packets_in_cwnd = m_cwnd / m_mss;
+++
+++ // we just recently dropped a packet and cut the cwnd in half,
+++ // don't do it again already
+++ if (m_last_drop_seq > 0 && p.seq_nr < m_last_drop_seq + packets_in_cwnd) return;
+++
+++ m_cwnd /= 2;
+++ m_last_drop_seq = p.seq_nr;
+++
+++ // TODO: this should really happen one second later to be accurate
+++ if (m_cwnd < m_mss) m_cwnd = m_mss;
+++ }
+++
+++ void tcp::socket::incoming_packet(aux::packet p)
+++ {
+++ switch (p.type)
+++ {
+++ case aux::packet::type_t::uninitialized:
+++ {
+++ assert(false && "uninitialized packet");
+++ return;
+++ }
+++ case aux::packet::type_t::ack:
+++ {
+++ // if the socket just became writeable, we need to notify the
+++ // client. First we want to know whether it was not writeable.
+++ const bool was_writeable = m_bytes_in_flight + m_mss > m_cwnd;
+++
+++ auto it = m_outstanding_packet_sizes.find(p.seq_nr);
+++ assert(it != m_outstanding_packet_sizes.end());
+++ const int acked_bytes = it->second;
+++ m_outstanding_packet_sizes.erase(it);
+++ assert(m_bytes_in_flight >= acked_bytes);
+++ m_bytes_in_flight -= acked_bytes;
+++
+++ // potentially resend packets
+++ while (!m_outgoing_packets.empty()
+++ && m_bytes_in_flight
+++ + int(m_outgoing_packets.front().buffer.size()) <= m_cwnd)
+++ {
+++ aux::packet pkt = std::move(m_outgoing_packets.front());
+++ m_outgoing_packets.erase(m_outgoing_packets.begin());
+++ send_packet(std::move(pkt));
+++ }
+++
+++ // update cwnd based on the number of bytes ACKed.
+++ // every round-trip, increase the window size by one packet
+++ // (MSS)
+++ m_cwnd += m_mss * acked_bytes / m_cwnd;
+++
+++ // TODO: implement slow-start
+++
+++ const bool is_writeable = m_bytes_in_flight + m_mss <= m_cwnd;
+++
+++ if (!was_writeable && is_writeable)
+++ maybe_wakeup_writer();
+++
+++ return;
+++ }
+++ case aux::packet::type_t::syn:
+++ {
+++ // TODO: return connection refused
+++ return;
+++ }
+++ case aux::packet::type_t::syn_ack:
+++ {
+++ assert(m_connect_handler);
+++ boost::system::error_code ec;
+++ post(m_io_service, aux::make_malloc(std::bind(std::move(m_connect_handler), ec)));
+++ m_connect_handler = nullptr;
+++ if (ec) m_channel.reset();
+++ else maybe_wakeup_writer();
+++ return;
+++ }
+++ case aux::packet::type_t::error:
+++ case aux::packet::type_t::payload:
+++ {
+++ aux::packet ack;
+++ ack.type = aux::packet::type_t::ack;
+++ ack.seq_nr = p.seq_nr;
+++
+++ int remote = m_channel->remote_idx(m_bound_to);
+++ ack.hops = m_channel->hops[remote];
+++ forward_packet(std::move(ack));
+++
+++ // if the sequence number is out-of-order, put it in the
+++ // m_incoming_packets queue
+++ if (p.seq_nr != m_next_incoming_seq)
+++ {
+++ if (p.seq_nr < m_next_incoming_seq)
+++ {
+++ std::printf("TCP: incoming sequence number lower (%" PRId64 ") "
+++ "than expected: %" PRId64 "\n", p.seq_nr, m_next_incoming_seq);
+++ }
+++
+++ m_reorder_buffer.emplace(p.seq_nr, std::move(p));
+++ return;
+++ }
+++
+++ // this packet was in-order. increment the expected next sequence
+++ // number.
+++ ++m_next_incoming_seq;
+++ m_incoming_queue.push_back(std::move(p));
+++
+++ // also, perhaps there are some packets that arrived out-of-order,
+++ // check to see
+++ auto it = m_reorder_buffer.find(m_next_incoming_seq);
+++ while (it != m_reorder_buffer.end())
+++ {
+++ aux::packet pkt = std::move(it->second);
+++ m_reorder_buffer.erase(it);
+++ m_incoming_queue.push_back(std::move(pkt));
+++ ++m_next_incoming_seq;
+++ it = m_reorder_buffer.find(m_next_incoming_seq);
+++ }
+++
+++ maybe_wakeup_reader();
+++ return;
+++ }
+++ }
+++ }
+++}
+++}
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/src/udp_socket.cpp
++@@ -0,0 +1,492 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include "simulator/packet.hpp"
+++#include "simulator/pcap.hpp"
+++#include "simulator/handler_allocator.hpp"
+++
+++#include <functional>
+++
+++#include "simulator/push_warnings.hpp"
+++#include <boost/system/error_code.hpp>
+++#include <boost/function.hpp>
+++#include "simulator/pop_warnings.hpp"
+++
+++typedef sim::chrono::high_resolution_clock::time_point time_point;
+++typedef sim::chrono::high_resolution_clock::duration duration;
+++
+++namespace sim {
+++namespace asio {
+++namespace ip {
+++
+++ udp::socket::socket(io_context& ios)
+++ : socket_base(ios)
+++ , m_next_send(chrono::high_resolution_clock::now())
+++ , m_recv_sender(nullptr)
+++ , m_recv_timer(ios)
+++ , m_send_timer(ios)
+++ , m_recv_null_buffers(0)
+++ , m_queue_size(0)
+++ , m_is_v4(true)
+++ {}
+++
+++ udp::socket::socket(socket&& s)
+++ : socket_base(std::move(s))
+++ , m_next_send(std::move(s.m_next_send))
+++ , m_send_handler(std::move(s.m_send_handler))
+++ , m_wait_send_handler(std::move(s.m_wait_send_handler))
+++ , m_recv_handler(std::move(s.m_recv_handler))
+++ , m_wait_recv_handler(std::move(s.m_wait_recv_handler))
+++ , m_recv_buffer(std::move(s.m_recv_buffer))
+++ , m_recv_sender(std::move(s.m_recv_sender))
+++ , m_recv_timer(std::move(s.m_recv_timer))
+++ , m_send_timer(std::move(s.m_send_timer))
+++ , m_incoming_queue(std::move(s.m_incoming_queue))
+++ , m_recv_null_buffers(std::move(s.m_recv_null_buffers))
+++ , m_queue_size(std::move(s.m_queue_size))
+++ , m_is_v4(s.m_is_v4)
+++ {
+++ if (m_forwarder) m_forwarder->reset(this);
+++ s.m_forwarder.reset();
+++ s.m_open = false;
+++ s.m_bound_to = ip::udp::endpoint();
+++ if (m_bound_to != ip::udp::endpoint())
+++ m_io_service.rebind_udp_socket(this, m_bound_to);
+++ }
+++
+++ udp::socket::~socket()
+++ {
+++ boost::system::error_code ec;
+++ close(ec);
+++ }
+++
+++ void udp::socket::bind(ip::udp::endpoint const& ep
+++ , boost::system::error_code& ec) try
+++ {
+++ if (!m_open)
+++ {
+++ ec = error::bad_descriptor;
+++ return;
+++ }
+++
+++ if (ep.address().is_v4() != m_is_v4)
+++ {
+++ ec = error::address_family_not_supported;
+++ return;
+++ }
+++
+++ ip::udp::endpoint addr = m_io_service.bind_udp_socket(this, ep, ec);
+++ if (ec) return;
+++ m_bound_to = addr;
+++ m_user_bound_to = addr;
+++ }
+++ catch (std::bad_alloc const&)
+++ {
+++ ec = make_error_code(boost::system::errc::not_enough_memory);
+++ }
+++ catch (boost::system::system_error const& err)
+++ {
+++ ec = err.code();
+++ }
+++
+++ void udp::socket::bind(ip::udp::endpoint const& ep)
+++ {
+++ boost::system::error_code ec;
+++ bind(ep, ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ }
+++
+++ void udp::socket::open(udp protocol
+++ , boost::system::error_code& ec) try
+++ {
+++ // TODO: what if it's already open?
+++ close(ec);
+++ m_open = true;
+++ m_is_v4 = (protocol == ip::udp::v4());
+++ m_forwarder = std::make_shared<aux::sink_forwarder>(this);
+++ }
+++ catch (std::bad_alloc const&)
+++ {
+++ ec = make_error_code(boost::system::errc::not_enough_memory);
+++ }
+++ catch (boost::system::system_error const& err)
+++ {
+++ ec = err.code();
+++ }
+++
+++ void udp::socket::open(udp protocol)
+++ {
+++ boost::system::error_code ec;
+++ open(protocol, ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ }
+++
+++ void udp::socket::close()
+++ {
+++ boost::system::error_code ec;
+++ close(ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ }
+++
+++ void udp::socket::close(boost::system::error_code& ec) try
+++ {
+++ if (m_bound_to != ip::udp::endpoint())
+++ {
+++ m_io_service.unbind_udp_socket(this, m_bound_to);
+++ m_bound_to = ip::udp::endpoint();
+++ m_user_bound_to = ip::udp::endpoint();
+++ }
+++ m_open = false;
+++
+++ // prevent any more packets from being delivered to this socket
+++ if (m_forwarder)
+++ {
+++ m_forwarder->reset();
+++ m_forwarder.reset();
+++ }
+++
+++ cancel(ec);
+++ }
+++ catch (std::bad_alloc const&)
+++ {
+++ ec = make_error_code(boost::system::errc::not_enough_memory);
+++ }
+++ catch (boost::system::system_error const& err)
+++ {
+++ ec = err.code();
+++ }
+++
+++ void udp::socket::cancel(boost::system::error_code&)
+++ {
+++ // cancel outstanding async operations
+++ abort_recv_handlers();
+++ abort_send_handlers();
+++ m_recv_timer.cancel();
+++ m_send_timer.cancel();
+++ return;
+++ }
+++
+++ void udp::socket::cancel()
+++ {
+++ boost::system::error_code ec;
+++ cancel(ec);
+++ if (ec) throw boost::system::system_error(ec);
+++ }
+++
+++ void udp::socket::abort_send_handlers()
+++ {
+++ if (m_send_handler)
+++ post(m_io_service, make_malloc(std::bind(std::ref(m_send_handler)
+++ , boost::system::error_code(error::operation_aborted), std::size_t(0))));
+++
+++ if (m_wait_send_handler)
+++ post(m_io_service, make_malloc(std::bind(std::ref(m_wait_send_handler)
+++ , boost::system::error_code(error::operation_aborted))));
+++
+++ m_send_timer.cancel();
+++ m_send_handler = nullptr;
+++ m_wait_send_handler = nullptr;
+++// m_send_buffer.clear();
+++ }
+++
+++ void udp::socket::abort_recv_handlers()
+++ {
+++ if (m_recv_handler)
+++ post(m_io_service, make_malloc(std::bind(std::move(m_recv_handler)
+++ , boost::system::error_code(error::operation_aborted), std::size_t(0))));
+++
+++ if (m_wait_recv_handler)
+++ post(m_io_service, make_malloc(std::bind(std::move(m_wait_recv_handler)
+++ , boost::system::error_code(error::operation_aborted))));
+++
+++ m_recv_timer.cancel();
+++ m_recv_handler = nullptr;
+++ m_wait_recv_handler = nullptr;
+++ m_recv_buffer.clear();
+++ }
+++
+++ void udp::socket::async_wait(socket_base::wait_type_t const w
+++ , aux::function<void(boost::system::error_code const&)> handler)
+++ {
+++ if (w == wait_type_t::wait_write)
+++ {
+++ abort_send_handlers();
+++
+++ time_point const now = chrono::high_resolution_clock::now();
+++ boost::system::error_code no_error;
+++ if (m_next_send - now > m_send_queue_time / 2)
+++ {
+++ // our send queue is too large. Defer
+++ m_recv_timer.expires_at(m_next_send + m_send_queue_time / 2);
+++
+++ m_wait_send_handler = std::move(handler);
+++ m_recv_timer.async_wait(make_malloc(std::bind(std::ref(m_wait_send_handler), no_error)));
+++ return;
+++ }
+++
+++ // the socket is writable, post the completion handler immediately
+++ post(m_io_service, make_malloc(std::bind(std::move(handler), no_error)));
+++ }
+++ else if (w == wait_type_t::wait_read)
+++ {
+++ abort_recv_handlers();
+++ async_wait_receive_impl(nullptr, std::move(handler));
+++ }
+++ }
+++
+++ std::size_t udp::socket::receive_from_impl(
+++ std::vector<asio::mutable_buffer> const& bufs
+++ , udp::endpoint* sender
+++ , socket_base::message_flags /* flags */
+++ , boost::system::error_code& ec)
+++ {
+++ assert(!bufs.empty());
+++ if (!m_open)
+++ {
+++ ec = boost::system::error_code(error::bad_descriptor);
+++ return 0;
+++ }
+++
+++ if (m_bound_to == udp::endpoint())
+++ {
+++ ec = boost::system::error_code(error::invalid_argument);
+++ return 0;
+++ }
+++
+++ if (m_incoming_queue.empty())
+++ {
+++ ec = boost::system::error_code(error::would_block);
+++ return 0;
+++ }
+++
+++ aux::packet& p = m_incoming_queue.front();
+++ if (sender) *sender = p.from;
+++
+++ int read = 0;
+++ for (auto const& buf : bufs)
+++ {
+++ char* ptr = static_cast<char*>(buf.data());
+++ int const len = int(buf.size());
+++ int const to_copy = (std::min)(int(p.buffer.size()), len);
+++ memcpy(ptr, p.buffer.data(), to_copy);
+++ read += to_copy;
+++ p.buffer.erase(p.buffer.begin(), p.buffer.begin() + to_copy);
+++ m_queue_size -= to_copy;
+++ if (p.buffer.empty()) break;
+++ }
+++
+++ m_incoming_queue.erase(m_incoming_queue.begin());
+++ return read;
+++ }
+++
+++ void udp::socket::async_wait_receive_impl(
+++ udp::endpoint* sender
+++ , aux::function<void(boost::system::error_code const&)> handler)
+++ {
+++ if (!m_open)
+++ {
+++ post(m_io_service, make_malloc(std::bind(std::move(handler)
+++ , boost::system::error_code(error::bad_descriptor))));
+++ return;
+++ }
+++
+++ if (m_bound_to == udp::endpoint())
+++ {
+++ post(m_io_service, make_malloc(std::bind(std::move(handler)
+++ , boost::system::error_code(error::invalid_argument))));
+++ return;
+++ }
+++
+++ if (!m_incoming_queue.empty())
+++ {
+++ post(m_io_service, make_malloc(std::bind(std::move(handler), boost::system::error_code())));
+++ return;
+++ }
+++
+++ m_recv_null_buffers = true;
+++ m_wait_recv_handler = std::move(handler);
+++ m_recv_sender = sender;
+++ }
+++
+++ void udp::socket::async_receive_from_impl(
+++ std::vector<asio::mutable_buffer> const& bufs
+++ , udp::endpoint* sender
+++ , socket_base::message_flags /* flags */
+++ , aux::function<void(boost::system::error_code const&
+++ , std::size_t)> handler)
+++ {
+++ assert(!bufs.empty());
+++
+++ boost::system::error_code ec;
+++ std::size_t bytes_transferred = receive_from_impl(bufs, sender, 0, ec);
+++ if (ec == boost::system::error_code(error::would_block))
+++ {
+++ m_recv_buffer = bufs;
+++ m_recv_handler = std::move(handler);
+++ m_recv_sender = sender;
+++ m_recv_null_buffers = false;
+++
+++ return;
+++ }
+++
+++ if (ec)
+++ {
+++ post(m_io_service, make_malloc(std::bind(std::move(handler), ec, std::size_t(0))));
+++ m_recv_handler = nullptr;
+++ m_recv_buffer.clear();
+++ m_recv_sender = nullptr;
+++ m_recv_null_buffers = false;
+++ return;
+++ }
+++
+++ post(m_io_service, make_malloc(std::bind(std::move(handler), ec, bytes_transferred)));
+++ m_recv_handler = nullptr;
+++ m_recv_buffer.clear();
+++ m_recv_sender = nullptr;
+++ m_recv_null_buffers = false;
+++ }
+++
+++ std::size_t udp::socket::send_to_impl(std::vector<asio::const_buffer> const& b
+++ , udp::endpoint const& dst, message_flags /* flags */
+++ , boost::system::error_code& ec)
+++ {
+++ assert(m_non_blocking && "blocking operations not supported");
+++
+++ if (m_bound_to == ip::udp::endpoint())
+++ {
+++ // the socket was not bound, bind to anything
+++ bind(udp::endpoint(), ec);
+++ if (ec) return 0;
+++ }
+++
+++ ec.clear();
+++ std::size_t ret = 0;
+++ for (std::vector<asio::const_buffer>::const_iterator i = b.begin()
+++ , end(b.end()); i != end; ++i)
+++ {
+++ ret += i->size();
+++ }
+++ if (ret == 0)
+++ {
+++ ec = boost::system::error_code(error::invalid_argument);
+++ return 0;
+++ }
+++
+++ time_point now = chrono::high_resolution_clock::now();
+++
+++ const int mtu = m_io_service.get_path_mtu(m_bound_to.address(), dst.address());
+++
+++ if (int(ret) > 65535)
+++ {
+++ ec = boost::system::error_code(error::message_size);
+++ return 0;
+++ }
+++
+++ if (m_dont_fragment && int(ret) > mtu)
+++ {
+++ // silently drop packet
+++ ec.clear();
+++ return ret;
+++ }
+++
+++ // determine the bandwidth in terms of nanoseconds / byte
+++ const double nanoseconds_per_byte = 1000000000.0
+++ / double(aux::nic_bandwidth);
+++
+++ if (m_next_send - now > m_send_queue_time)
+++ {
+++ // our send queue is too large.
+++ ec = boost::system::error_code(asio::error::would_block);
+++ return 0;
+++ }
+++
+++ route hops = m_io_service.find_udp_socket(*this, dst);
+++ if (hops.empty())
+++ {
+++ // the packet is silently dropped
+++ // TODO: it would be nice if this would result in a round-trip time
+++ // with an ICMP host unreachable or connection_refused error
+++ return ret;
+++ }
+++
+++ hops.prepend(m_io_service.get_outgoing_route(m_bound_to.address()));
+++
+++ m_next_send = std::max(now, m_next_send);
+++
+++ aux::packet p;
+++ p.overhead = 28;
+++ p.type = aux::packet::type_t::payload;
+++ p.from = m_bound_to;
+++ p.hops = hops;
+++ for (std::vector<asio::const_buffer>::const_iterator i = b.begin()
+++ , end(b.end()); i != end; ++i)
+++ {
+++ p.buffer.insert(p.buffer.end(), static_cast<std::uint8_t const*>(i->data())
+++ , static_cast<std::uint8_t const*>(i->data()) + i->size());
+++ }
+++
+++ auto* log = m_io_service.sim().get_pcap();
+++ if (log) log->log_udp(p, m_bound_to, dst);
+++
+++ int const packet_size = int(p.buffer.size() + p.overhead);
+++ forward_packet(std::move(p));
+++
+++ m_next_send += chrono::duration_cast<duration>(chrono::nanoseconds(
+++ boost::int64_t(nanoseconds_per_byte * packet_size)));
+++
+++ return ret;
+++ }
+++
+++ void udp::socket::incoming_packet(aux::packet p)
+++ {
+++ int const packet_size = int(p.buffer.size() + p.overhead);
+++
+++ // silent drop. If the application isn't reading fast enough, drop packets
+++ // TODO: make this limit controlled by SO_RECVBUF socket option
+++ if (m_queue_size + packet_size > 256 * 1024) return;
+++
+++ m_queue_size += int(p.buffer.size());
+++ m_incoming_queue.push_back(std::move(p));
+++
+++ maybe_wakeup_reader();
+++ }
+++
+++ void udp::socket::maybe_wakeup_reader()
+++ {
+++ if (m_incoming_queue.size() != 1 || (!m_recv_handler && !m_wait_recv_handler)) return;
+++
+++ // there is an outstanding operation waiting for an incoming packet
+++ if (m_recv_null_buffers)
+++ {
+++ async_wait_receive_impl(m_recv_sender, std::move(m_wait_recv_handler));
+++ }
+++ else
+++ {
+++ async_receive_from_impl(m_recv_buffer, m_recv_sender, 0, std::move(m_recv_handler));
+++ }
+++
+++// m_recv_handler = nullptr;
+++// m_recv_buffer.clear();
+++// m_recv_sender = nullptr;
+++ }
+++
+++} // ip
+++} // asio
+++} // sim
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/acceptor.cpp
++@@ -0,0 +1,183 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include <functional>
+++
+++#include "catch.hpp"
+++
+++#ifdef __GNUC__
+++// for CATCH's CHECK macro
+++#pragma GCC diagnostic ignored "-Wparentheses"
+++#endif
+++
+++using namespace sim::asio;
+++using namespace sim::chrono;
+++using sim::simulation;
+++using sim::default_config;
+++using namespace std::placeholders;
+++
+++namespace {
+++char send_buffer[10000];
+++char recv_buffer[10000];
+++int num_received = 0;
+++int num_sent = 0;
+++
+++void on_sent(boost::system::error_code const& ec, std::size_t bytes_transferred
+++ , ip::tcp::socket& sock)
+++{
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++ if (ec)
+++ {
+++ std::printf("[%4d] send error %s\n", millis, ec.message().c_str());
+++ return;
+++ }
+++
+++ num_sent += int(bytes_transferred);
+++
+++ std::printf("[%4d] sent %d bytes\n", millis, int(bytes_transferred));
+++ std::printf("closing\n");
+++ sock.close();
+++}
+++
+++void on_receive(boost::system::error_code const& ec
+++ , std::size_t bytes_transferred, ip::tcp::socket& sock)
+++{
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++ if (ec)
+++ {
+++ std::printf("[%4d] receive error %s\n", millis, ec.message().c_str());
+++ return;
+++ }
+++
+++ num_received += int(bytes_transferred);
+++
+++ std::printf("[%4d] received %d bytes\n", millis, int(bytes_transferred));
+++
+++ sock.async_read_some(sim::asio::buffer(recv_buffer, sizeof(recv_buffer))
+++ , std::bind(&on_receive, _1, _2, std::ref(sock)));
+++}
+++
+++void incoming_connection(boost::system::error_code const& ec
+++ , ip::tcp::socket& sock, ip::tcp::endpoint const& ep)
+++{
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++ if (ec)
+++ {
+++ std::printf("[%4d] error while accepting connection: %s\n"
+++ , millis, ec.message().c_str());
+++ return;
+++ }
+++
+++ boost::system::error_code err;
+++ ip::tcp::endpoint remote_endpoint = sock.remote_endpoint(err);
+++ REQUIRE(!ec);
+++ ip::tcp::endpoint local_endpoint = sock.local_endpoint(err);
+++ REQUIRE(!ec);
+++ std::printf("[%4d] received incoming connection from: %s:%d. local endpoint: %s:%d\n"
+++ , millis, ep.address().to_string().c_str(), ep.port()
+++ , local_endpoint.address().to_string().c_str(), local_endpoint.port());
+++ CHECK(local_endpoint.port() == 1337);
+++ CHECK(local_endpoint.address().to_string() == "40.30.20.10");
+++ CHECK(remote_endpoint.port() != 0);
+++ CHECK(remote_endpoint.address().to_string() == "10.20.30.40");
+++
+++ sock.async_read_some(sim::asio::buffer(recv_buffer, sizeof(recv_buffer))
+++ , std::bind(&on_receive, _1, _2, std::ref(sock)));
+++}
+++
+++void on_connected(boost::system::error_code const& ec
+++ , ip::tcp::socket& sock)
+++{
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++ if (ec)
+++ {
+++ std::printf("[%4d] error while connecting: %s\n", millis, ec.message().c_str());
+++ return;
+++ }
+++
+++ boost::system::error_code err;
+++ ip::tcp::endpoint remote_endpoint = sock.remote_endpoint(err);
+++ REQUIRE(!ec);
+++ ip::tcp::endpoint local_endpoint = sock.local_endpoint(err);
+++ REQUIRE(!ec);
+++
+++ std::printf("[%4d] made outgoing connection to: %s:%d. local endpoint: %s:%d\n"
+++ , millis
+++ , remote_endpoint.address().to_string().c_str(), remote_endpoint.port()
+++ , local_endpoint.address().to_string().c_str(), local_endpoint.port());
+++
+++ CHECK(remote_endpoint.port() == 1337);
+++ CHECK(remote_endpoint.address().to_string() == "40.30.20.10");
+++ CHECK(local_endpoint.port() != 0);
+++ CHECK(local_endpoint.address().to_string() == "10.20.30.40");
+++
+++ std::printf("sending %d bytes\n", int(sizeof(send_buffer)));
+++ sock.async_write_some(sim::asio::buffer(send_buffer, sizeof(send_buffer))
+++ , std::bind(&on_sent, _1, _2, std::ref(sock)));
+++}
+++
+++}
+++
+++TEST_CASE("accept incoming connection on acceptor socket", "[acceptor]")
+++{
+++ default_config cfg;
+++ simulation sim(cfg);
+++ io_context incoming_ios(sim, ip::make_address_v4("40.30.20.10"));
+++ io_context outgoing_ios(sim, ip::make_address_v4("10.20.30.40"));
+++ ip::tcp::acceptor listener(incoming_ios);
+++
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++
+++ boost::system::error_code ec;
+++ listener.open(ip::tcp::v4(), ec);
+++ REQUIRE(!ec);
+++ listener.bind(ip::tcp::endpoint(ip::address(), 1337), ec);
+++ REQUIRE(!ec);
+++ listener.listen(10, ec);
+++ REQUIRE(!ec);
+++
+++ ip::tcp::socket incoming(incoming_ios);
+++ ip::tcp::endpoint remote_endpoint;
+++ listener.async_accept(incoming, remote_endpoint
+++ , std::bind(&incoming_connection, _1, std::ref(incoming)
+++ , std::cref(remote_endpoint)));
+++
+++ dump_network_graph(sim, "accept.dot");
+++
+++ std::printf("[%4d] connecting\n", millis);
+++ ip::tcp::socket outgoing(outgoing_ios);
+++ outgoing.open(ip::tcp::v4(), ec);
+++ REQUIRE(!ec);
+++ outgoing.async_connect(ip::tcp::endpoint(ip::make_address("40.30.20.10")
+++ , 1337), std::bind(&on_connected, _1, std::ref(outgoing)));
+++
+++ sim.run();
+++
+++ millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++
+++ CHECK(num_received == num_sent);
+++ CHECK(num_received > 0);
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/catch.hpp
++@@ -0,0 +1,14057 @@
+++
+++// Copyright Catch2 Authors
+++// Distributed under the Boost Software License, Version 1.0.
+++// (See accompanying file LICENSE.txt or copy at
+++// https://www.boost.org/LICENSE_1_0.txt)
+++
+++// SPDX-License-Identifier: BSL-1.0
+++
+++// Catch v3.6.0
+++// Generated: 2024-05-05 20:53:27.071502
+++// ----------------------------------------------------------
+++// This file is an amalgamation of multiple different files.
+++// You probably shouldn't edit it directly.
+++// ----------------------------------------------------------
+++#ifndef CATCH_AMALGAMATED_HPP_INCLUDED
+++#define CATCH_AMALGAMATED_HPP_INCLUDED
+++
+++
+++/** \file
+++ * This is a convenience header for Catch2. It includes **all** of Catch2 headers.
+++ *
+++ * Generally the Catch2 users should use specific includes they need,
+++ * but this header can be used instead for ease-of-experimentation, or
+++ * just plain convenience, at the cost of (significantly) increased
+++ * compilation times.
+++ *
+++ * When a new header is added to either the top level folder, or to the
+++ * corresponding internal subfolder, it should be added here. Headers
+++ * added to the various subparts (e.g. matchers, generators, etc...),
+++ * should go their respective catch-all headers.
+++ */
+++
+++#ifndef CATCH_ALL_HPP_INCLUDED
+++#define CATCH_ALL_HPP_INCLUDED
+++
+++
+++
+++/** \file
+++ * This is a convenience header for Catch2's benchmarking. It includes
+++ * **all** of Catch2 headers related to benchmarking.
+++ *
+++ * Generally the Catch2 users should use specific includes they need,
+++ * but this header can be used instead for ease-of-experimentation, or
+++ * just plain convenience, at the cost of (significantly) increased
+++ * compilation times.
+++ *
+++ * When a new header is added to either the `benchmark` folder, or to
+++ * the corresponding internal (detail) subfolder, it should be added here.
+++ */
+++
+++#ifndef CATCH_BENCHMARK_ALL_HPP_INCLUDED
+++#define CATCH_BENCHMARK_ALL_HPP_INCLUDED
+++
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_BENCHMARK_HPP_INCLUDED
+++#define CATCH_BENCHMARK_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+++#define CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+++
+++// Detect a number of compiler features - by compiler
+++// The following features are defined:
+++//
+++// CATCH_CONFIG_WINDOWS_SEH : is Windows SEH supported?
+++// CATCH_CONFIG_POSIX_SIGNALS : are POSIX signals supported?
+++// CATCH_CONFIG_DISABLE_EXCEPTIONS : Are exceptions enabled?
+++// ****************
+++// Note to maintainers: if new toggles are added please document them
+++// in configuration.md, too
+++// ****************
+++
+++// In general each macro has a _NO_<feature name> form
+++// (e.g. CATCH_CONFIG_NO_POSIX_SIGNALS) which disables the feature.
+++// Many features, at point of detection, define an _INTERNAL_ macro, so they
+++// can be combined, en-mass, with the _NO_ forms later.
+++
+++
+++
+++#ifndef CATCH_PLATFORM_HPP_INCLUDED
+++#define CATCH_PLATFORM_HPP_INCLUDED
+++
+++// See e.g.:
+++// https://opensource.apple.com/source/CarbonHeaders/CarbonHeaders-18.1/TargetConditionals.h.auto.html
+++#ifdef __APPLE__
+++# ifndef __has_extension
+++# define __has_extension(x) 0
+++# endif
+++# include <TargetConditionals.h>
+++# if (defined(TARGET_OS_OSX) && TARGET_OS_OSX == 1) || \
+++ (defined(TARGET_OS_MAC) && TARGET_OS_MAC == 1)
+++# define CATCH_PLATFORM_MAC
+++# elif (defined(TARGET_OS_IPHONE) && TARGET_OS_IPHONE == 1)
+++# define CATCH_PLATFORM_IPHONE
+++# endif
+++
+++#elif defined(linux) || defined(__linux) || defined(__linux__)
+++# define CATCH_PLATFORM_LINUX
+++
+++#elif defined(WIN32) || defined(__WIN32__) || defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__)
+++# define CATCH_PLATFORM_WINDOWS
+++
+++# if defined( WINAPI_FAMILY ) && ( WINAPI_FAMILY == WINAPI_FAMILY_APP )
+++# define CATCH_PLATFORM_WINDOWS_UWP
+++# endif
+++
+++#elif defined(__ORBIS__) || defined(__PROSPERO__)
+++# define CATCH_PLATFORM_PLAYSTATION
+++
+++#endif
+++
+++#endif // CATCH_PLATFORM_HPP_INCLUDED
+++
+++#ifdef __cplusplus
+++
+++# if (__cplusplus >= 201703L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 201703L)
+++# define CATCH_CPP17_OR_GREATER
+++# endif
+++
+++# if (__cplusplus >= 202002L) || (defined(_MSVC_LANG) && _MSVC_LANG >= 202002L)
+++# define CATCH_CPP20_OR_GREATER
+++# endif
+++
+++#endif
+++
+++// Only GCC compiler should be used in this block, so other compilers trying to
+++// mask themselves as GCC should be ignored.
+++#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && !defined(__CUDACC__) && !defined(__LCC__) && !defined(__NVCOMPILER)
+++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic push" )
+++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "GCC diagnostic pop" )
+++
+++// This only works on GCC 9+. so we have to also add a global suppression of Wparentheses
+++// for older versions of GCC.
+++# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+++ _Pragma( "GCC diagnostic ignored \"-Wparentheses\"" )
+++
+++# define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
+++ _Pragma( "GCC diagnostic ignored \"-Wunused-result\"" )
+++
+++# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ _Pragma( "GCC diagnostic ignored \"-Wunused-variable\"" )
+++
+++# define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+++ _Pragma( "GCC diagnostic ignored \"-Wuseless-cast\"" )
+++
+++# define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+++ _Pragma( "GCC diagnostic ignored \"-Wshadow\"" )
+++
+++# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__)
+++
+++#endif
+++
+++#if defined(__NVCOMPILER)
+++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "diag push" )
+++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "diag pop" )
+++# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress declared_but_not_referenced" )
+++#endif
+++
+++#if defined(__CUDACC__) && !defined(__clang__)
+++# ifdef __NVCC_DIAG_PRAGMA_SUPPORT__
+++// New pragmas introduced in CUDA 11.5+
+++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "nv_diagnostic push" )
+++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "nv_diagnostic pop" )
+++# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "nv_diag_suppress 177" )
+++# else
+++# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS _Pragma( "diag_suppress 177" )
+++# endif
+++#endif
+++
+++// clang-cl defines _MSC_VER as well as __clang__, which could cause the
+++// start/stop internal suppression macros to be double defined.
+++#if defined(__clang__) && !defined(_MSC_VER)
+++
+++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic push" )
+++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION _Pragma( "clang diagnostic pop" )
+++
+++#endif // __clang__ && !_MSC_VER
+++
+++#if defined(__clang__)
+++
+++// As of this writing, IBM XL's implementation of __builtin_constant_p has a bug
+++// which results in calls to destructors being emitted for each temporary,
+++// without a matching initialization. In practice, this can result in something
+++// like `std::string::~string` being called on an uninitialized value.
+++//
+++// For example, this code will likely segfault under IBM XL:
+++// ```
+++// REQUIRE(std::string("12") + "34" == "1234")
+++// ```
+++//
+++// Similarly, NVHPC's implementation of `__builtin_constant_p` has a bug which
+++// results in calls to the immediately evaluated lambda expressions to be
+++// reported as unevaluated lambdas.
+++// https://developer.nvidia.com/nvidia_bug/3321845.
+++//
+++// Therefore, `CATCH_INTERNAL_IGNORE_BUT_WARN` is not implemented.
+++# if !defined(__ibmxl__) && !defined(__CUDACC__) && !defined( __NVCOMPILER )
+++# define CATCH_INTERNAL_IGNORE_BUT_WARN(...) (void)__builtin_constant_p(__VA_ARGS__) /* NOLINT(cppcoreguidelines-pro-type-vararg, hicpp-vararg) */
+++# endif
+++
+++
+++# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+++ _Pragma( "clang diagnostic ignored \"-Wexit-time-destructors\"" ) \
+++ _Pragma( "clang diagnostic ignored \"-Wglobal-constructors\"")
+++
+++# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+++ _Pragma( "clang diagnostic ignored \"-Wparentheses\"" )
+++
+++# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ _Pragma( "clang diagnostic ignored \"-Wunused-variable\"" )
+++
+++# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+++ _Pragma( "clang diagnostic ignored \"-Wgnu-zero-variadic-macro-arguments\"" )
+++
+++# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+++ _Pragma( "clang diagnostic ignored \"-Wunused-template\"" )
+++
+++# define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+++ _Pragma( "clang diagnostic ignored \"-Wcomma\"" )
+++
+++# define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+++ _Pragma( "clang diagnostic ignored \"-Wshadow\"" )
+++
+++#endif // __clang__
+++
+++
+++////////////////////////////////////////////////////////////////////////////////
+++// We know some environments not to support full POSIX signals
+++#if defined( CATCH_PLATFORM_WINDOWS ) || \
+++ defined( CATCH_PLATFORM_PLAYSTATION ) || \
+++ defined( __CYGWIN__ ) || \
+++ defined( __QNX__ ) || \
+++ defined( __EMSCRIPTEN__ ) || \
+++ defined( __DJGPP__ ) || \
+++ defined( __OS400__ )
+++# define CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS
+++#else
+++# define CATCH_INTERNAL_CONFIG_POSIX_SIGNALS
+++#endif
+++
+++////////////////////////////////////////////////////////////////////////////////
+++// Assume that some platforms do not support getenv.
+++#if defined( CATCH_PLATFORM_WINDOWS_UWP ) || \
+++ defined( CATCH_PLATFORM_PLAYSTATION ) || \
+++ defined( _GAMING_XBOX )
+++# define CATCH_INTERNAL_CONFIG_NO_GETENV
+++#else
+++# define CATCH_INTERNAL_CONFIG_GETENV
+++#endif
+++
+++////////////////////////////////////////////////////////////////////////////////
+++// Android somehow still does not support std::to_string
+++#if defined(__ANDROID__)
+++# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+++#endif
+++
+++////////////////////////////////////////////////////////////////////////////////
+++// Not all Windows environments support SEH properly
+++#if defined(__MINGW32__)
+++# define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+++#endif
+++
+++////////////////////////////////////////////////////////////////////////////////
+++// PS4
+++#if defined(__ORBIS__)
+++# define CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE
+++#endif
+++
+++////////////////////////////////////////////////////////////////////////////////
+++// Cygwin
+++#ifdef __CYGWIN__
+++
+++// Required for some versions of Cygwin to declare gettimeofday
+++// see: http://stackoverflow.com/questions/36901803/gettimeofday-not-declared-in-this-scope-cygwin
+++# define _BSD_SOURCE
+++// some versions of cygwin (most) do not support std::to_string. Use the libstd check.
+++// https://gcc.gnu.org/onlinedocs/gcc-4.8.2/libstdc++/api/a01053_source.html line 2812-2813
+++# if !((__cplusplus >= 201103L) && defined(_GLIBCXX_USE_C99) \
+++ && !defined(_GLIBCXX_HAVE_BROKEN_VSWPRINTF))
+++
+++# define CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING
+++
+++# endif
+++#endif // __CYGWIN__
+++
+++////////////////////////////////////////////////////////////////////////////////
+++// Visual C++
+++#if defined(_MSC_VER)
+++
+++// We want to defer to nvcc-specific warning suppression if we are compiled
+++// with nvcc masquerading for MSVC.
+++# if !defined( __CUDACC__ )
+++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ __pragma( warning( push ) )
+++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+++ __pragma( warning( pop ) )
+++# endif
+++
+++// Universal Windows platform does not support SEH
+++// Or console colours (or console at all...)
+++# if defined(CATCH_PLATFORM_WINDOWS_UWP)
+++# define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
+++# else
+++# define CATCH_INTERNAL_CONFIG_WINDOWS_SEH
+++# endif
+++
+++// MSVC traditional preprocessor needs some workaround for __VA_ARGS__
+++// _MSVC_TRADITIONAL == 0 means new conformant preprocessor
+++// _MSVC_TRADITIONAL == 1 means old traditional non-conformant preprocessor
+++# if !defined(__clang__) // Handle Clang masquerading for msvc
+++# if !defined(_MSVC_TRADITIONAL) || (defined(_MSVC_TRADITIONAL) && _MSVC_TRADITIONAL)
+++# define CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++# endif // MSVC_TRADITIONAL
+++# endif // __clang__
+++
+++#endif // _MSC_VER
+++
+++#if defined(_REENTRANT) || defined(_MSC_VER)
+++// Enable async processing, as -pthread is specified or no additional linking is required
+++# define CATCH_INTERNAL_CONFIG_USE_ASYNC
+++#endif // _MSC_VER
+++
+++////////////////////////////////////////////////////////////////////////////////
+++// Check if we are compiled with -fno-exceptions or equivalent
+++#if defined(__EXCEPTIONS) || defined(__cpp_exceptions) || defined(_CPPUNWIND)
+++# define CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED
+++#endif
+++
+++
+++////////////////////////////////////////////////////////////////////////////////
+++// Embarcadero C++Build
+++#if defined(__BORLANDC__)
+++ #define CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN
+++#endif
+++
+++////////////////////////////////////////////////////////////////////////////////
+++
+++// RTX is a special version of Windows that is real time.
+++// This means that it is detected as Windows, but does not provide
+++// the same set of capabilities as real Windows does.
+++#if defined(UNDER_RTSS) || defined(RTX64_BUILD)
+++ #define CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH
+++ #define CATCH_INTERNAL_CONFIG_NO_ASYNC
+++ #define CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32
+++#endif
+++
+++#if !defined(_GLIBCXX_USE_C99_MATH_TR1)
+++#define CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER
+++#endif
+++
+++// Various stdlib support checks that require __has_include
+++#if defined(__has_include)
+++ // Check if string_view is available and usable
+++ #if __has_include(<string_view>) && defined(CATCH_CPP17_OR_GREATER)
+++ # define CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW
+++ #endif
+++
+++ // Check if optional is available and usable
+++ # if __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+++ # define CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL
+++ # endif // __has_include(<optional>) && defined(CATCH_CPP17_OR_GREATER)
+++
+++ // Check if byte is available and usable
+++ # if __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+++ # include <cstddef>
+++ # if defined(__cpp_lib_byte) && (__cpp_lib_byte > 0)
+++ # define CATCH_INTERNAL_CONFIG_CPP17_BYTE
+++ # endif
+++ # endif // __has_include(<cstddef>) && defined(CATCH_CPP17_OR_GREATER)
+++
+++ // Check if variant is available and usable
+++ # if __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+++ # if defined(__clang__) && (__clang_major__ < 8)
+++ // work around clang bug with libstdc++ https://bugs.llvm.org/show_bug.cgi?id=31852
+++ // fix should be in clang 8, workaround in libstdc++ 8.2
+++ # include <ciso646>
+++ # if defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+++ # define CATCH_CONFIG_NO_CPP17_VARIANT
+++ # else
+++ # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+++ # endif // defined(__GLIBCXX__) && defined(_GLIBCXX_RELEASE) && (_GLIBCXX_RELEASE < 9)
+++ # else
+++ # define CATCH_INTERNAL_CONFIG_CPP17_VARIANT
+++ # endif // defined(__clang__) && (__clang_major__ < 8)
+++ # endif // __has_include(<variant>) && defined(CATCH_CPP17_OR_GREATER)
+++#endif // defined(__has_include)
+++
+++
+++#if defined(CATCH_INTERNAL_CONFIG_WINDOWS_SEH) && !defined(CATCH_CONFIG_NO_WINDOWS_SEH) && !defined(CATCH_CONFIG_WINDOWS_SEH) && !defined(CATCH_INTERNAL_CONFIG_NO_WINDOWS_SEH)
+++# define CATCH_CONFIG_WINDOWS_SEH
+++#endif
+++// This is set by default, because we assume that unix compilers are posix-signal-compatible by default.
+++#if defined(CATCH_INTERNAL_CONFIG_POSIX_SIGNALS) && !defined(CATCH_INTERNAL_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_NO_POSIX_SIGNALS) && !defined(CATCH_CONFIG_POSIX_SIGNALS)
+++# define CATCH_CONFIG_POSIX_SIGNALS
+++#endif
+++
+++#if defined(CATCH_INTERNAL_CONFIG_GETENV) && !defined(CATCH_INTERNAL_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_NO_GETENV) && !defined(CATCH_CONFIG_GETENV)
+++# define CATCH_CONFIG_GETENV
+++#endif
+++
+++#if !defined(CATCH_INTERNAL_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_NO_CPP11_TO_STRING) && !defined(CATCH_CONFIG_CPP11_TO_STRING)
+++# define CATCH_CONFIG_CPP11_TO_STRING
+++#endif
+++
+++#if defined(CATCH_INTERNAL_CONFIG_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_NO_CPP17_OPTIONAL) && !defined(CATCH_CONFIG_CPP17_OPTIONAL)
+++# define CATCH_CONFIG_CPP17_OPTIONAL
+++#endif
+++
+++#if defined(CATCH_INTERNAL_CONFIG_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_NO_CPP17_STRING_VIEW) && !defined(CATCH_CONFIG_CPP17_STRING_VIEW)
+++# define CATCH_CONFIG_CPP17_STRING_VIEW
+++#endif
+++
+++#if defined(CATCH_INTERNAL_CONFIG_CPP17_VARIANT) && !defined(CATCH_CONFIG_NO_CPP17_VARIANT) && !defined(CATCH_CONFIG_CPP17_VARIANT)
+++# define CATCH_CONFIG_CPP17_VARIANT
+++#endif
+++
+++#if defined(CATCH_INTERNAL_CONFIG_CPP17_BYTE) && !defined(CATCH_CONFIG_NO_CPP17_BYTE) && !defined(CATCH_CONFIG_CPP17_BYTE)
+++# define CATCH_CONFIG_CPP17_BYTE
+++#endif
+++
+++
+++#if defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+++# define CATCH_INTERNAL_CONFIG_NEW_CAPTURE
+++#endif
+++
+++#if defined(CATCH_INTERNAL_CONFIG_NEW_CAPTURE) && !defined(CATCH_INTERNAL_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NO_NEW_CAPTURE) && !defined(CATCH_CONFIG_NEW_CAPTURE)
+++# define CATCH_CONFIG_NEW_CAPTURE
+++#endif
+++
+++#if !defined( CATCH_INTERNAL_CONFIG_EXCEPTIONS_ENABLED ) && \
+++ !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS ) && \
+++ !defined( CATCH_CONFIG_NO_DISABLE_EXCEPTIONS )
+++# define CATCH_CONFIG_DISABLE_EXCEPTIONS
+++#endif
+++
+++#if defined(CATCH_INTERNAL_CONFIG_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_NO_POLYFILL_ISNAN) && !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+++# define CATCH_CONFIG_POLYFILL_ISNAN
+++#endif
+++
+++#if defined(CATCH_INTERNAL_CONFIG_USE_ASYNC) && !defined(CATCH_INTERNAL_CONFIG_NO_ASYNC) && !defined(CATCH_CONFIG_NO_USE_ASYNC) && !defined(CATCH_CONFIG_USE_ASYNC)
+++# define CATCH_CONFIG_USE_ASYNC
+++#endif
+++
+++#if defined(CATCH_INTERNAL_CONFIG_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_NO_GLOBAL_NEXTAFTER) && !defined(CATCH_CONFIG_GLOBAL_NEXTAFTER)
+++# define CATCH_CONFIG_GLOBAL_NEXTAFTER
+++#endif
+++
+++
+++// Even if we do not think the compiler has that warning, we still have
+++// to provide a macro that can be used by the code.
+++#if !defined(CATCH_INTERNAL_START_WARNINGS_SUPPRESSION)
+++# define CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+++#endif
+++#if !defined(CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION)
+++# define CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+++#endif
+++#if !defined(CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS)
+++# define CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS
+++#endif
+++#if !defined(CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS)
+++# define CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+++#endif
+++#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT)
+++# define CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT
+++#endif
+++#if !defined(CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS)
+++# define CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS
+++#endif
+++#if !defined(CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS)
+++# define CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS
+++#endif
+++#if !defined(CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS)
+++# define CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS
+++#endif
+++#if !defined( CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS )
+++# define CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+++#endif
+++#if !defined( CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS )
+++# define CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS
+++#endif
+++#if !defined( CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS )
+++# define CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS
+++#endif
+++
+++
+++// The goal of this macro is to avoid evaluation of the arguments, but
+++// still have the compiler warn on problems inside...
+++#if !defined(CATCH_INTERNAL_IGNORE_BUT_WARN)
+++# define CATCH_INTERNAL_IGNORE_BUT_WARN(...)
+++#endif
+++
+++#if defined(__APPLE__) && defined(__apple_build_version__) && (__clang_major__ < 10)
+++# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+++#elif defined(__clang__) && (__clang_major__ < 5)
+++# undef CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS
+++#endif
+++
+++
+++#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+++#define CATCH_TRY if ((true))
+++#define CATCH_CATCH_ALL if ((false))
+++#define CATCH_CATCH_ANON(type) if ((false))
+++#else
+++#define CATCH_TRY try
+++#define CATCH_CATCH_ALL catch (...)
+++#define CATCH_CATCH_ANON(type) catch (type)
+++#endif
+++
+++#if defined(CATCH_INTERNAL_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_NO_TRADITIONAL_MSVC_PREPROCESSOR) && !defined(CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR)
+++#define CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++#endif
+++
+++#if defined( CATCH_PLATFORM_WINDOWS ) && \
+++ !defined( CATCH_CONFIG_COLOUR_WIN32 ) && \
+++ !defined( CATCH_CONFIG_NO_COLOUR_WIN32 ) && \
+++ !defined( CATCH_INTERNAL_CONFIG_NO_COLOUR_WIN32 )
+++# define CATCH_CONFIG_COLOUR_WIN32
+++#endif
+++
+++#if defined( CATCH_CONFIG_SHARED_LIBRARY ) && defined( _MSC_VER ) && \
+++ !defined( CATCH_CONFIG_STATIC )
+++# ifdef Catch2_EXPORTS
+++# define CATCH_EXPORT //__declspec( dllexport ) // not needed
+++# else
+++# define CATCH_EXPORT __declspec( dllimport )
+++# endif
+++#else
+++# define CATCH_EXPORT
+++#endif
+++
+++#endif // CATCH_COMPILER_CAPABILITIES_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_CONTEXT_HPP_INCLUDED
+++#define CATCH_CONTEXT_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++
+++ class IResultCapture;
+++ class IConfig;
+++
+++ class Context {
+++ IConfig const* m_config = nullptr;
+++ IResultCapture* m_resultCapture = nullptr;
+++
+++ CATCH_EXPORT static Context* currentContext;
+++ friend Context& getCurrentMutableContext();
+++ friend Context const& getCurrentContext();
+++ static void createContext();
+++ friend void cleanUpContext();
+++
+++ public:
+++ IResultCapture* getResultCapture() const { return m_resultCapture; }
+++ IConfig const* getConfig() const { return m_config; }
+++ void setResultCapture( IResultCapture* resultCapture );
+++ void setConfig( IConfig const* config );
+++ };
+++
+++ Context& getCurrentMutableContext();
+++
+++ inline Context const& getCurrentContext() {
+++ // We duplicate the logic from `getCurrentMutableContext` here,
+++ // to avoid paying the call overhead in debug mode.
+++ if ( !Context::currentContext ) { Context::createContext(); }
+++ // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+++ return *Context::currentContext;
+++ }
+++
+++ void cleanUpContext();
+++
+++ class SimplePcg32;
+++ SimplePcg32& sharedRng();
+++}
+++
+++#endif // CATCH_CONTEXT_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
+++#define CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
+++
+++#include <type_traits>
+++
+++//! Replacement for std::move with better compile time performance
+++#define CATCH_MOVE(...) static_cast<std::remove_reference_t<decltype(__VA_ARGS__)>&&>(__VA_ARGS__)
+++
+++//! Replacement for std::forward with better compile time performance
+++#define CATCH_FORWARD(...) static_cast<decltype(__VA_ARGS__)&&>(__VA_ARGS__)
+++
+++#endif // CATCH_MOVE_AND_FORWARD_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
+++#define CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
+++
+++namespace Catch {
+++
+++ //! Used to signal that an assertion macro failed
+++ struct TestFailureException{};
+++ //! Used to signal that the remainder of a test should be skipped
+++ struct TestSkipException {};
+++
+++ /**
+++ * Outlines throwing of `TestFailureException` into a single TU
+++ *
+++ * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers.
+++ */
+++ [[noreturn]] void throw_test_failure_exception();
+++
+++ /**
+++ * Outlines throwing of `TestSkipException` into a single TU
+++ *
+++ * Also handles `CATCH_CONFIG_DISABLE_EXCEPTIONS` for callers.
+++ */
+++ [[noreturn]] void throw_test_skip_exception();
+++
+++} // namespace Catch
+++
+++#endif // CATCH_TEST_FAILURE_EXCEPTION_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_UNIQUE_NAME_HPP_INCLUDED
+++#define CATCH_UNIQUE_NAME_HPP_INCLUDED
+++
+++
+++
+++
+++/** \file
+++ * Wrapper for the CONFIG configuration option
+++ *
+++ * When generating internal unique names, there are two options. Either
+++ * we mix in the current line number, or mix in an incrementing number.
+++ * We prefer the latter, using `__COUNTER__`, but users might want to
+++ * use the former.
+++ */
+++
+++#ifndef CATCH_CONFIG_COUNTER_HPP_INCLUDED
+++#define CATCH_CONFIG_COUNTER_HPP_INCLUDED
+++
+++
+++#if ( !defined(__JETBRAINS_IDE__) || __JETBRAINS_IDE__ >= 20170300L )
+++ #define CATCH_INTERNAL_CONFIG_COUNTER
+++#endif
+++
+++#if defined( CATCH_INTERNAL_CONFIG_COUNTER ) && \
+++ !defined( CATCH_CONFIG_NO_COUNTER ) && \
+++ !defined( CATCH_CONFIG_COUNTER )
+++# define CATCH_CONFIG_COUNTER
+++#endif
+++
+++
+++#endif // CATCH_CONFIG_COUNTER_HPP_INCLUDED
+++#define INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line ) name##line
+++#define INTERNAL_CATCH_UNIQUE_NAME_LINE( name, line ) INTERNAL_CATCH_UNIQUE_NAME_LINE2( name, line )
+++#ifdef CATCH_CONFIG_COUNTER
+++# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __COUNTER__ )
+++#else
+++# define INTERNAL_CATCH_UNIQUE_NAME( name ) INTERNAL_CATCH_UNIQUE_NAME_LINE( name, __LINE__ )
+++#endif
+++
+++#endif // CATCH_UNIQUE_NAME_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
+++#define CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
+++
+++#include <string>
+++#include <chrono>
+++
+++
+++
+++#ifndef CATCH_STRINGREF_HPP_INCLUDED
+++#define CATCH_STRINGREF_HPP_INCLUDED
+++
+++#include <cstddef>
+++#include <string>
+++#include <iosfwd>
+++#include <cassert>
+++
+++#include <cstring>
+++
+++namespace Catch {
+++
+++ /// A non-owning string class (similar to the forthcoming std::string_view)
+++ /// Note that, because a StringRef may be a substring of another string,
+++ /// it may not be null terminated.
+++ class StringRef {
+++ public:
+++ using size_type = std::size_t;
+++ using const_iterator = const char*;
+++
+++ static constexpr size_type npos{ static_cast<size_type>( -1 ) };
+++
+++ private:
+++ static constexpr char const* const s_empty = "";
+++
+++ char const* m_start = s_empty;
+++ size_type m_size = 0;
+++
+++ public: // construction
+++ constexpr StringRef() noexcept = default;
+++
+++ StringRef( char const* rawChars ) noexcept;
+++
+++ constexpr StringRef( char const* rawChars, size_type size ) noexcept
+++ : m_start( rawChars ),
+++ m_size( size )
+++ {}
+++
+++ StringRef( std::string const& stdString ) noexcept
+++ : m_start( stdString.c_str() ),
+++ m_size( stdString.size() )
+++ {}
+++
+++ explicit operator std::string() const {
+++ return std::string(m_start, m_size);
+++ }
+++
+++ public: // operators
+++ auto operator == ( StringRef other ) const noexcept -> bool {
+++ return m_size == other.m_size
+++ && (std::memcmp( m_start, other.m_start, m_size ) == 0);
+++ }
+++ auto operator != (StringRef other) const noexcept -> bool {
+++ return !(*this == other);
+++ }
+++
+++ constexpr auto operator[] ( size_type index ) const noexcept -> char {
+++ assert(index < m_size);
+++ return m_start[index];
+++ }
+++
+++ bool operator<(StringRef rhs) const noexcept;
+++
+++ public: // named queries
+++ constexpr auto empty() const noexcept -> bool {
+++ return m_size == 0;
+++ }
+++ constexpr auto size() const noexcept -> size_type {
+++ return m_size;
+++ }
+++
+++ // Returns a substring of [start, start + length).
+++ // If start + length > size(), then the substring is [start, size()).
+++ // If start > size(), then the substring is empty.
+++ constexpr StringRef substr(size_type start, size_type length) const noexcept {
+++ if (start < m_size) {
+++ const auto shortened_size = m_size - start;
+++ return StringRef(m_start + start, (shortened_size < length) ? shortened_size : length);
+++ } else {
+++ return StringRef();
+++ }
+++ }
+++
+++ // Returns the current start pointer. May not be null-terminated.
+++ constexpr char const* data() const noexcept {
+++ return m_start;
+++ }
+++
+++ constexpr const_iterator begin() const { return m_start; }
+++ constexpr const_iterator end() const { return m_start + m_size; }
+++
+++
+++ friend std::string& operator += (std::string& lhs, StringRef rhs);
+++ friend std::ostream& operator << (std::ostream& os, StringRef str);
+++ friend std::string operator+(StringRef lhs, StringRef rhs);
+++
+++ /**
+++ * Provides a three-way comparison with rhs
+++ *
+++ * Returns negative number if lhs < rhs, 0 if lhs == rhs, and a positive
+++ * number if lhs > rhs
+++ */
+++ int compare( StringRef rhs ) const;
+++ };
+++
+++
+++ constexpr auto operator ""_sr( char const* rawChars, std::size_t size ) noexcept -> StringRef {
+++ return StringRef( rawChars, size );
+++ }
+++} // namespace Catch
+++
+++constexpr auto operator ""_catch_sr( char const* rawChars, std::size_t size ) noexcept -> Catch::StringRef {
+++ return Catch::StringRef( rawChars, size );
+++}
+++
+++#endif // CATCH_STRINGREF_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_RESULT_TYPE_HPP_INCLUDED
+++#define CATCH_RESULT_TYPE_HPP_INCLUDED
+++
+++namespace Catch {
+++
+++ // ResultWas::OfType enum
+++ struct ResultWas { enum OfType {
+++ Unknown = -1,
+++ Ok = 0,
+++ Info = 1,
+++ Warning = 2,
+++ // TODO: Should explicit skip be considered "not OK" (cf. isOk)? I.e., should it have the failure bit?
+++ ExplicitSkip = 4,
+++
+++ FailureBit = 0x10,
+++
+++ ExpressionFailed = FailureBit | 1,
+++ ExplicitFailure = FailureBit | 2,
+++
+++ Exception = 0x100 | FailureBit,
+++
+++ ThrewException = Exception | 1,
+++ DidntThrowException = Exception | 2,
+++
+++ FatalErrorCondition = 0x200 | FailureBit
+++
+++ }; };
+++
+++ bool isOk( ResultWas::OfType resultType );
+++ bool isJustInfo( int flags );
+++
+++
+++ // ResultDisposition::Flags enum
+++ struct ResultDisposition { enum Flags {
+++ Normal = 0x01,
+++
+++ ContinueOnFailure = 0x02, // Failures fail test, but execution continues
+++ FalseTest = 0x04, // Prefix expression with !
+++ SuppressFail = 0x08 // Failures are reported but do not fail the test
+++ }; };
+++
+++ ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs );
+++
+++ bool shouldContinueOnFailure( int flags );
+++ inline bool isFalseTest( int flags ) { return ( flags & ResultDisposition::FalseTest ) != 0; }
+++ bool shouldSuppressFailure( int flags );
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_RESULT_TYPE_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_UNIQUE_PTR_HPP_INCLUDED
+++#define CATCH_UNIQUE_PTR_HPP_INCLUDED
+++
+++#include <cassert>
+++#include <type_traits>
+++
+++
+++namespace Catch {
+++namespace Detail {
+++ /**
+++ * A reimplementation of `std::unique_ptr` for improved compilation performance
+++ *
+++ * Does not support arrays nor custom deleters.
+++ */
+++ template <typename T>
+++ class unique_ptr {
+++ T* m_ptr;
+++ public:
+++ constexpr unique_ptr(std::nullptr_t = nullptr):
+++ m_ptr{}
+++ {}
+++ explicit constexpr unique_ptr(T* ptr):
+++ m_ptr(ptr)
+++ {}
+++
+++ template <typename U, typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+++ unique_ptr(unique_ptr<U>&& from):
+++ m_ptr(from.release())
+++ {}
+++
+++ template <typename U, typename = std::enable_if_t<std::is_base_of<T, U>::value>>
+++ unique_ptr& operator=(unique_ptr<U>&& from) {
+++ reset(from.release());
+++
+++ return *this;
+++ }
+++
+++ unique_ptr(unique_ptr const&) = delete;
+++ unique_ptr& operator=(unique_ptr const&) = delete;
+++
+++ unique_ptr(unique_ptr&& rhs) noexcept:
+++ m_ptr(rhs.m_ptr) {
+++ rhs.m_ptr = nullptr;
+++ }
+++ unique_ptr& operator=(unique_ptr&& rhs) noexcept {
+++ reset(rhs.release());
+++
+++ return *this;
+++ }
+++
+++ ~unique_ptr() {
+++ delete m_ptr;
+++ }
+++
+++ T& operator*() {
+++ assert(m_ptr);
+++ return *m_ptr;
+++ }
+++ T const& operator*() const {
+++ assert(m_ptr);
+++ return *m_ptr;
+++ }
+++ T* operator->() noexcept {
+++ assert(m_ptr);
+++ return m_ptr;
+++ }
+++ T const* operator->() const noexcept {
+++ assert(m_ptr);
+++ return m_ptr;
+++ }
+++
+++ T* get() { return m_ptr; }
+++ T const* get() const { return m_ptr; }
+++
+++ void reset(T* ptr = nullptr) {
+++ delete m_ptr;
+++ m_ptr = ptr;
+++ }
+++
+++ T* release() {
+++ auto temp = m_ptr;
+++ m_ptr = nullptr;
+++ return temp;
+++ }
+++
+++ explicit operator bool() const {
+++ return m_ptr;
+++ }
+++
+++ friend void swap(unique_ptr& lhs, unique_ptr& rhs) {
+++ auto temp = lhs.m_ptr;
+++ lhs.m_ptr = rhs.m_ptr;
+++ rhs.m_ptr = temp;
+++ }
+++ };
+++
+++ //! Specialization to cause compile-time error for arrays
+++ template <typename T>
+++ class unique_ptr<T[]>;
+++
+++ template <typename T, typename... Args>
+++ unique_ptr<T> make_unique(Args&&... args) {
+++ return unique_ptr<T>(new T(CATCH_FORWARD(args)...));
+++ }
+++
+++
+++} // end namespace Detail
+++} // end namespace Catch
+++
+++#endif // CATCH_UNIQUE_PTR_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
+++#define CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
+++
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_CLOCK_HPP_INCLUDED
+++#define CATCH_CLOCK_HPP_INCLUDED
+++
+++#include <chrono>
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ using IDuration = std::chrono::nanoseconds;
+++ using FDuration = std::chrono::duration<double, std::nano>;
+++
+++ template <typename Clock>
+++ using TimePoint = typename Clock::time_point;
+++
+++ using default_clock = std::chrono::steady_clock;
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_CLOCK_HPP_INCLUDED
+++
+++namespace Catch {
+++
+++ // We cannot forward declare the type with default template argument
+++ // multiple times, so it is split out into a separate header so that
+++ // we can prevent multiple declarations in dependees
+++ template <typename Duration = Benchmark::FDuration>
+++ struct BenchmarkStats;
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_BENCHMARK_STATS_FWD_HPP_INCLUDED
+++
+++namespace Catch {
+++
+++ class AssertionResult;
+++ struct AssertionInfo;
+++ struct SectionInfo;
+++ struct SectionEndInfo;
+++ struct MessageInfo;
+++ struct MessageBuilder;
+++ struct Counts;
+++ struct AssertionReaction;
+++ struct SourceLineInfo;
+++
+++ class ITransientExpression;
+++ class IGeneratorTracker;
+++
+++ struct BenchmarkInfo;
+++
+++ namespace Generators {
+++ class GeneratorUntypedBase;
+++ using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;
+++ }
+++
+++
+++ class IResultCapture {
+++ public:
+++ virtual ~IResultCapture();
+++
+++ virtual void notifyAssertionStarted( AssertionInfo const& info ) = 0;
+++ virtual bool sectionStarted( StringRef sectionName,
+++ SourceLineInfo const& sectionLineInfo,
+++ Counts& assertions ) = 0;
+++ virtual void sectionEnded( SectionEndInfo&& endInfo ) = 0;
+++ virtual void sectionEndedEarly( SectionEndInfo&& endInfo ) = 0;
+++
+++ virtual IGeneratorTracker*
+++ acquireGeneratorTracker( StringRef generatorName,
+++ SourceLineInfo const& lineInfo ) = 0;
+++ virtual IGeneratorTracker*
+++ createGeneratorTracker( StringRef generatorName,
+++ SourceLineInfo lineInfo,
+++ Generators::GeneratorBasePtr&& generator ) = 0;
+++
+++ virtual void benchmarkPreparing( StringRef name ) = 0;
+++ virtual void benchmarkStarting( BenchmarkInfo const& info ) = 0;
+++ virtual void benchmarkEnded( BenchmarkStats<> const& stats ) = 0;
+++ virtual void benchmarkFailed( StringRef error ) = 0;
+++
+++ virtual void pushScopedMessage( MessageInfo const& message ) = 0;
+++ virtual void popScopedMessage( MessageInfo const& message ) = 0;
+++
+++ virtual void emplaceUnscopedMessage( MessageBuilder&& builder ) = 0;
+++
+++ virtual void handleFatalErrorCondition( StringRef message ) = 0;
+++
+++ virtual void handleExpr
+++ ( AssertionInfo const& info,
+++ ITransientExpression const& expr,
+++ AssertionReaction& reaction ) = 0;
+++ virtual void handleMessage
+++ ( AssertionInfo const& info,
+++ ResultWas::OfType resultType,
+++ StringRef message,
+++ AssertionReaction& reaction ) = 0;
+++ virtual void handleUnexpectedExceptionNotThrown
+++ ( AssertionInfo const& info,
+++ AssertionReaction& reaction ) = 0;
+++ virtual void handleUnexpectedInflightException
+++ ( AssertionInfo const& info,
+++ std::string&& message,
+++ AssertionReaction& reaction ) = 0;
+++ virtual void handleIncomplete
+++ ( AssertionInfo const& info ) = 0;
+++ virtual void handleNonExpr
+++ ( AssertionInfo const &info,
+++ ResultWas::OfType resultType,
+++ AssertionReaction &reaction ) = 0;
+++
+++
+++
+++ virtual bool lastAssertionPassed() = 0;
+++ virtual void assertionPassed() = 0;
+++
+++ // Deprecated, do not use:
+++ virtual std::string getCurrentTestName() const = 0;
+++ virtual const AssertionResult* getLastResult() const = 0;
+++ virtual void exceptionEarlyReported() = 0;
+++ };
+++
+++ IResultCapture& getResultCapture();
+++}
+++
+++#endif // CATCH_INTERFACES_CAPTURE_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_INTERFACES_CONFIG_HPP_INCLUDED
+++#define CATCH_INTERFACES_CONFIG_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_NONCOPYABLE_HPP_INCLUDED
+++#define CATCH_NONCOPYABLE_HPP_INCLUDED
+++
+++namespace Catch {
+++ namespace Detail {
+++
+++ //! Deriving classes become noncopyable and nonmovable
+++ class NonCopyable {
+++ NonCopyable( NonCopyable const& ) = delete;
+++ NonCopyable( NonCopyable&& ) = delete;
+++ NonCopyable& operator=( NonCopyable const& ) = delete;
+++ NonCopyable& operator=( NonCopyable&& ) = delete;
+++
+++ protected:
+++ NonCopyable() noexcept = default;
+++ };
+++
+++ } // namespace Detail
+++} // namespace Catch
+++
+++#endif // CATCH_NONCOPYABLE_HPP_INCLUDED
+++
+++#include <chrono>
+++#include <iosfwd>
+++#include <string>
+++#include <vector>
+++
+++namespace Catch {
+++
+++ enum class Verbosity {
+++ Quiet = 0,
+++ Normal,
+++ High
+++ };
+++
+++ struct WarnAbout { enum What {
+++ Nothing = 0x00,
+++ //! A test case or leaf section did not run any assertions
+++ NoAssertions = 0x01,
+++ //! A command line test spec matched no test cases
+++ UnmatchedTestSpec = 0x02,
+++ }; };
+++
+++ enum class ShowDurations {
+++ DefaultForReporter,
+++ Always,
+++ Never
+++ };
+++ enum class TestRunOrder {
+++ Declared,
+++ LexicographicallySorted,
+++ Randomized
+++ };
+++ enum class ColourMode : std::uint8_t {
+++ //! Let Catch2 pick implementation based on platform detection
+++ PlatformDefault,
+++ //! Use ANSI colour code escapes
+++ ANSI,
+++ //! Use Win32 console colour API
+++ Win32,
+++ //! Don't use any colour
+++ None
+++ };
+++ struct WaitForKeypress { enum When {
+++ Never,
+++ BeforeStart = 1,
+++ BeforeExit = 2,
+++ BeforeStartAndExit = BeforeStart | BeforeExit
+++ }; };
+++
+++ class TestSpec;
+++ class IStream;
+++
+++ class IConfig : public Detail::NonCopyable {
+++ public:
+++ virtual ~IConfig();
+++
+++ virtual bool allowThrows() const = 0;
+++ virtual StringRef name() const = 0;
+++ virtual bool includeSuccessfulResults() const = 0;
+++ virtual bool shouldDebugBreak() const = 0;
+++ virtual bool warnAboutMissingAssertions() const = 0;
+++ virtual bool warnAboutUnmatchedTestSpecs() const = 0;
+++ virtual bool zeroTestsCountAsSuccess() const = 0;
+++ virtual int abortAfter() const = 0;
+++ virtual bool showInvisibles() const = 0;
+++ virtual ShowDurations showDurations() const = 0;
+++ virtual double minDuration() const = 0;
+++ virtual TestSpec const& testSpec() const = 0;
+++ virtual bool hasTestFilters() const = 0;
+++ virtual std::vector<std::string> const& getTestsOrTags() const = 0;
+++ virtual TestRunOrder runOrder() const = 0;
+++ virtual uint32_t rngSeed() const = 0;
+++ virtual unsigned int shardCount() const = 0;
+++ virtual unsigned int shardIndex() const = 0;
+++ virtual ColourMode defaultColourMode() const = 0;
+++ virtual std::vector<std::string> const& getSectionsToRun() const = 0;
+++ virtual Verbosity verbosity() const = 0;
+++
+++ virtual bool skipBenchmarks() const = 0;
+++ virtual bool benchmarkNoAnalysis() const = 0;
+++ virtual unsigned int benchmarkSamples() const = 0;
+++ virtual double benchmarkConfidenceInterval() const = 0;
+++ virtual unsigned int benchmarkResamples() const = 0;
+++ virtual std::chrono::milliseconds benchmarkWarmupTime() const = 0;
+++ };
+++}
+++
+++#endif // CATCH_INTERFACES_CONFIG_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
+++#define CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
+++
+++
+++#include <string>
+++
+++namespace Catch {
+++
+++ class TestCaseHandle;
+++ struct TestCaseInfo;
+++ class ITestCaseRegistry;
+++ class IExceptionTranslatorRegistry;
+++ class IExceptionTranslator;
+++ class ReporterRegistry;
+++ class IReporterFactory;
+++ class ITagAliasRegistry;
+++ class ITestInvoker;
+++ class IMutableEnumValuesRegistry;
+++ struct SourceLineInfo;
+++
+++ class StartupExceptionRegistry;
+++ class EventListenerFactory;
+++
+++ using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
+++
+++ class IRegistryHub {
+++ public:
+++ virtual ~IRegistryHub(); // = default
+++
+++ virtual ReporterRegistry const& getReporterRegistry() const = 0;
+++ virtual ITestCaseRegistry const& getTestCaseRegistry() const = 0;
+++ virtual ITagAliasRegistry const& getTagAliasRegistry() const = 0;
+++ virtual IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const = 0;
+++
+++
+++ virtual StartupExceptionRegistry const& getStartupExceptionRegistry() const = 0;
+++ };
+++
+++ class IMutableRegistryHub {
+++ public:
+++ virtual ~IMutableRegistryHub(); // = default
+++ virtual void registerReporter( std::string const& name, IReporterFactoryPtr factory ) = 0;
+++ virtual void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) = 0;
+++ virtual void registerTest(Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker) = 0;
+++ virtual void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) = 0;
+++ virtual void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) = 0;
+++ virtual void registerStartupException() noexcept = 0;
+++ virtual IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() = 0;
+++ };
+++
+++ IRegistryHub const& getRegistryHub();
+++ IMutableRegistryHub& getMutableRegistryHub();
+++ void cleanUp();
+++ std::string translateActiveException();
+++
+++}
+++
+++#endif // CATCH_INTERFACES_REGISTRY_HUB_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_BENCHMARK_STATS_HPP_INCLUDED
+++#define CATCH_BENCHMARK_STATS_HPP_INCLUDED
+++
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_ESTIMATE_HPP_INCLUDED
+++#define CATCH_ESTIMATE_HPP_INCLUDED
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ template <typename Type>
+++ struct Estimate {
+++ Type point;
+++ Type lower_bound;
+++ Type upper_bound;
+++ double confidence_interval;
+++ };
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_ESTIMATE_HPP_INCLUDED
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED
+++#define CATCH_OUTLIER_CLASSIFICATION_HPP_INCLUDED
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ struct OutlierClassification {
+++ int samples_seen = 0;
+++ int low_severe = 0; // more than 3 times IQR below Q1
+++ int low_mild = 0; // 1.5 to 3 times IQR below Q1
+++ int high_mild = 0; // 1.5 to 3 times IQR above Q3
+++ int high_severe = 0; // more than 3 times IQR above Q3
+++
+++ int total() const {
+++ return low_severe + low_mild + high_mild + high_severe;
+++ }
+++ };
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_OUTLIERS_CLASSIFICATION_HPP_INCLUDED
+++// The fwd decl & default specialization needs to be seen by VS2017 before
+++// BenchmarkStats itself, or VS2017 will report compilation error.
+++
+++#include <string>
+++#include <vector>
+++
+++namespace Catch {
+++
+++ struct BenchmarkInfo {
+++ std::string name;
+++ double estimatedDuration;
+++ int iterations;
+++ unsigned int samples;
+++ unsigned int resamples;
+++ double clockResolution;
+++ double clockCost;
+++ };
+++
+++ // We need to keep template parameter for backwards compatibility,
+++ // but we also do not want to use the template paraneter.
+++ template <class Dummy>
+++ struct BenchmarkStats {
+++ BenchmarkInfo info;
+++
+++ std::vector<Benchmark::FDuration> samples;
+++ Benchmark::Estimate<Benchmark::FDuration> mean;
+++ Benchmark::Estimate<Benchmark::FDuration> standardDeviation;
+++ Benchmark::OutlierClassification outliers;
+++ double outlierVariance;
+++ };
+++
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_BENCHMARK_STATS_HPP_INCLUDED
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_ENVIRONMENT_HPP_INCLUDED
+++#define CATCH_ENVIRONMENT_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ struct EnvironmentEstimate {
+++ FDuration mean;
+++ OutlierClassification outliers;
+++ };
+++ struct Environment {
+++ EnvironmentEstimate clock_resolution;
+++ EnvironmentEstimate clock_cost;
+++ };
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_ENVIRONMENT_HPP_INCLUDED
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_EXECUTION_PLAN_HPP_INCLUDED
+++#define CATCH_EXECUTION_PLAN_HPP_INCLUDED
+++
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
+++#define CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
+++
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_CHRONOMETER_HPP_INCLUDED
+++#define CATCH_CHRONOMETER_HPP_INCLUDED
+++
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_OPTIMIZER_HPP_INCLUDED
+++#define CATCH_OPTIMIZER_HPP_INCLUDED
+++
+++#if defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)
+++# include <atomic> // atomic_thread_fence
+++#endif
+++
+++
+++#include <type_traits>
+++
+++namespace Catch {
+++ namespace Benchmark {
+++#if defined(__GNUC__) || defined(__clang__)
+++ template <typename T>
+++ inline void keep_memory(T* p) {
+++ asm volatile("" : : "g"(p) : "memory");
+++ }
+++ inline void keep_memory() {
+++ asm volatile("" : : : "memory");
+++ }
+++
+++ namespace Detail {
+++ inline void optimizer_barrier() { keep_memory(); }
+++ } // namespace Detail
+++#elif defined(_MSC_VER) || defined(__IAR_SYSTEMS_ICC__)
+++
+++#if defined(_MSVC_VER)
+++#pragma optimize("", off)
+++#elif defined(__IAR_SYSTEMS_ICC__)
+++// For IAR the pragma only affects the following function
+++#pragma optimize=disable
+++#endif
+++ template <typename T>
+++ inline void keep_memory(T* p) {
+++ // thanks @milleniumbug
+++ *reinterpret_cast<char volatile*>(p) = *reinterpret_cast<char const volatile*>(p);
+++ }
+++ // TODO equivalent keep_memory()
+++#if defined(_MSVC_VER)
+++#pragma optimize("", on)
+++#endif
+++
+++ namespace Detail {
+++ inline void optimizer_barrier() {
+++ std::atomic_thread_fence(std::memory_order_seq_cst);
+++ }
+++ } // namespace Detail
+++
+++#endif
+++
+++ template <typename T>
+++ inline void deoptimize_value(T&& x) {
+++ keep_memory(&x);
+++ }
+++
+++ template <typename Fn, typename... Args>
+++ inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<!std::is_same<void, decltype(fn(args...))>::value> {
+++ deoptimize_value(CATCH_FORWARD(fn) (CATCH_FORWARD(args)...));
+++ }
+++
+++ template <typename Fn, typename... Args>
+++ inline auto invoke_deoptimized(Fn&& fn, Args&&... args) -> std::enable_if_t<std::is_same<void, decltype(fn(args...))>::value> {
+++ CATCH_FORWARD((fn)) (CATCH_FORWARD(args)...);
+++ }
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_OPTIMIZER_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_META_HPP_INCLUDED
+++#define CATCH_META_HPP_INCLUDED
+++
+++#include <type_traits>
+++
+++namespace Catch {
+++ template <typename>
+++ struct true_given : std::true_type {};
+++
+++ struct is_callable_tester {
+++ template <typename Fun, typename... Args>
+++ static true_given<decltype(std::declval<Fun>()(std::declval<Args>()...))> test(int);
+++ template <typename...>
+++ static std::false_type test(...);
+++ };
+++
+++ template <typename T>
+++ struct is_callable;
+++
+++ template <typename Fun, typename... Args>
+++ struct is_callable<Fun(Args...)> : decltype(is_callable_tester::test<Fun, Args...>(0)) {};
+++
+++
+++#if defined(__cpp_lib_is_invocable) && __cpp_lib_is_invocable >= 201703
+++ // std::result_of is deprecated in C++17 and removed in C++20. Hence, it is
+++ // replaced with std::invoke_result here.
+++ template <typename Func, typename... U>
+++ using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::invoke_result_t<Func, U...>>>;
+++#else
+++ template <typename Func, typename... U>
+++ using FunctionReturnType = std::remove_reference_t<std::remove_cv_t<std::result_of_t<Func(U...)>>>;
+++#endif
+++
+++} // namespace Catch
+++
+++namespace mpl_{
+++ struct na;
+++}
+++
+++#endif // CATCH_META_HPP_INCLUDED
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ namespace Detail {
+++ struct ChronometerConcept {
+++ virtual void start() = 0;
+++ virtual void finish() = 0;
+++ virtual ~ChronometerConcept(); // = default;
+++
+++ ChronometerConcept() = default;
+++ ChronometerConcept(ChronometerConcept const&) = default;
+++ ChronometerConcept& operator=(ChronometerConcept const&) = default;
+++ };
+++ template <typename Clock>
+++ struct ChronometerModel final : public ChronometerConcept {
+++ void start() override { started = Clock::now(); }
+++ void finish() override { finished = Clock::now(); }
+++
+++ IDuration elapsed() const {
+++ return std::chrono::duration_cast<std::chrono::nanoseconds>(
+++ finished - started );
+++ }
+++
+++ TimePoint<Clock> started;
+++ TimePoint<Clock> finished;
+++ };
+++ } // namespace Detail
+++
+++ struct Chronometer {
+++ public:
+++ template <typename Fun>
+++ void measure(Fun&& fun) { measure(CATCH_FORWARD(fun), is_callable<Fun(int)>()); }
+++
+++ int runs() const { return repeats; }
+++
+++ Chronometer(Detail::ChronometerConcept& meter, int repeats_)
+++ : impl(&meter)
+++ , repeats(repeats_) {}
+++
+++ private:
+++ template <typename Fun>
+++ void measure(Fun&& fun, std::false_type) {
+++ measure([&fun](int) { return fun(); }, std::true_type());
+++ }
+++
+++ template <typename Fun>
+++ void measure(Fun&& fun, std::true_type) {
+++ Detail::optimizer_barrier();
+++ impl->start();
+++ for (int i = 0; i < repeats; ++i) invoke_deoptimized(fun, i);
+++ impl->finish();
+++ Detail::optimizer_barrier();
+++ }
+++
+++ Detail::ChronometerConcept* impl;
+++ int repeats;
+++ };
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_CHRONOMETER_HPP_INCLUDED
+++
+++#include <type_traits>
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ namespace Detail {
+++ template <typename T, typename U>
+++ struct is_related
+++ : std::is_same<std::decay_t<T>, std::decay_t<U>> {};
+++
+++ /// We need to reinvent std::function because every piece of code that might add overhead
+++ /// in a measurement context needs to have consistent performance characteristics so that we
+++ /// can account for it in the measurement.
+++ /// Implementations of std::function with optimizations that aren't always applicable, like
+++ /// small buffer optimizations, are not uncommon.
+++ /// This is effectively an implementation of std::function without any such optimizations;
+++ /// it may be slow, but it is consistently slow.
+++ struct BenchmarkFunction {
+++ private:
+++ struct callable {
+++ virtual void call(Chronometer meter) const = 0;
+++ virtual Catch::Detail::unique_ptr<callable> clone() const = 0;
+++ virtual ~callable(); // = default;
+++
+++ callable() = default;
+++ callable(callable const&) = default;
+++ callable& operator=(callable const&) = default;
+++ };
+++ template <typename Fun>
+++ struct model : public callable {
+++ model(Fun&& fun_) : fun(CATCH_MOVE(fun_)) {}
+++ model(Fun const& fun_) : fun(fun_) {}
+++
+++ Catch::Detail::unique_ptr<callable> clone() const override {
+++ return Catch::Detail::make_unique<model<Fun>>( *this );
+++ }
+++
+++ void call(Chronometer meter) const override {
+++ call(meter, is_callable<Fun(Chronometer)>());
+++ }
+++ void call(Chronometer meter, std::true_type) const {
+++ fun(meter);
+++ }
+++ void call(Chronometer meter, std::false_type) const {
+++ meter.measure(fun);
+++ }
+++
+++ Fun fun;
+++ };
+++
+++ struct do_nothing { void operator()() const {} };
+++
+++ template <typename T>
+++ BenchmarkFunction(model<T>* c) : f(c) {}
+++
+++ public:
+++ BenchmarkFunction()
+++ : f(new model<do_nothing>{ {} }) {}
+++
+++ template <typename Fun,
+++ std::enable_if_t<!is_related<Fun, BenchmarkFunction>::value, int> = 0>
+++ BenchmarkFunction(Fun&& fun)
+++ : f(new model<std::decay_t<Fun>>(CATCH_FORWARD(fun))) {}
+++
+++ BenchmarkFunction( BenchmarkFunction&& that ) noexcept:
+++ f( CATCH_MOVE( that.f ) ) {}
+++
+++ BenchmarkFunction(BenchmarkFunction const& that)
+++ : f(that.f->clone()) {}
+++
+++ BenchmarkFunction&
+++ operator=( BenchmarkFunction&& that ) noexcept {
+++ f = CATCH_MOVE( that.f );
+++ return *this;
+++ }
+++
+++ BenchmarkFunction& operator=(BenchmarkFunction const& that) {
+++ f = that.f->clone();
+++ return *this;
+++ }
+++
+++ void operator()(Chronometer meter) const { f->call(meter); }
+++
+++ private:
+++ Catch::Detail::unique_ptr<callable> f;
+++ };
+++ } // namespace Detail
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_BENCHMARK_FUNCTION_HPP_INCLUDED
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_REPEAT_HPP_INCLUDED
+++#define CATCH_REPEAT_HPP_INCLUDED
+++
+++#include <type_traits>
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ namespace Detail {
+++ template <typename Fun>
+++ struct repeater {
+++ void operator()(int k) const {
+++ for (int i = 0; i < k; ++i) {
+++ fun();
+++ }
+++ }
+++ Fun fun;
+++ };
+++ template <typename Fun>
+++ repeater<std::decay_t<Fun>> repeat(Fun&& fun) {
+++ return { CATCH_FORWARD(fun) };
+++ }
+++ } // namespace Detail
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_REPEAT_HPP_INCLUDED
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
+++#define CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
+++
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_MEASURE_HPP_INCLUDED
+++#define CATCH_MEASURE_HPP_INCLUDED
+++
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_COMPLETE_INVOKE_HPP_INCLUDED
+++#define CATCH_COMPLETE_INVOKE_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ namespace Detail {
+++ template <typename T>
+++ struct CompleteType { using type = T; };
+++ template <>
+++ struct CompleteType<void> { struct type {}; };
+++
+++ template <typename T>
+++ using CompleteType_t = typename CompleteType<T>::type;
+++
+++ template <typename Result>
+++ struct CompleteInvoker {
+++ template <typename Fun, typename... Args>
+++ static Result invoke(Fun&& fun, Args&&... args) {
+++ return CATCH_FORWARD(fun)(CATCH_FORWARD(args)...);
+++ }
+++ };
+++ template <>
+++ struct CompleteInvoker<void> {
+++ template <typename Fun, typename... Args>
+++ static CompleteType_t<void> invoke(Fun&& fun, Args&&... args) {
+++ CATCH_FORWARD(fun)(CATCH_FORWARD(args)...);
+++ return {};
+++ }
+++ };
+++
+++ // invoke and not return void :(
+++ template <typename Fun, typename... Args>
+++ CompleteType_t<FunctionReturnType<Fun, Args...>> complete_invoke(Fun&& fun, Args&&... args) {
+++ return CompleteInvoker<FunctionReturnType<Fun, Args...>>::invoke(CATCH_FORWARD(fun), CATCH_FORWARD(args)...);
+++ }
+++
+++ } // namespace Detail
+++
+++ template <typename Fun>
+++ Detail::CompleteType_t<FunctionReturnType<Fun>> user_code(Fun&& fun) {
+++ return Detail::complete_invoke(CATCH_FORWARD(fun));
+++ }
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_COMPLETE_INVOKE_HPP_INCLUDED
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_TIMING_HPP_INCLUDED
+++#define CATCH_TIMING_HPP_INCLUDED
+++
+++
+++#include <type_traits>
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ template <typename Result>
+++ struct Timing {
+++ IDuration elapsed;
+++ Result result;
+++ int iterations;
+++ };
+++ template <typename Func, typename... Args>
+++ using TimingOf = Timing<Detail::CompleteType_t<FunctionReturnType<Func, Args...>>>;
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_TIMING_HPP_INCLUDED
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ namespace Detail {
+++ template <typename Clock, typename Fun, typename... Args>
+++ TimingOf<Fun, Args...> measure(Fun&& fun, Args&&... args) {
+++ auto start = Clock::now();
+++ auto&& r = Detail::complete_invoke(fun, CATCH_FORWARD(args)...);
+++ auto end = Clock::now();
+++ auto delta = end - start;
+++ return { delta, CATCH_FORWARD(r), 1 };
+++ }
+++ } // namespace Detail
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_MEASURE_HPP_INCLUDED
+++
+++#include <type_traits>
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ namespace Detail {
+++ template <typename Clock, typename Fun>
+++ TimingOf<Fun, int> measure_one(Fun&& fun, int iters, std::false_type) {
+++ return Detail::measure<Clock>(fun, iters);
+++ }
+++ template <typename Clock, typename Fun>
+++ TimingOf<Fun, Chronometer> measure_one(Fun&& fun, int iters, std::true_type) {
+++ Detail::ChronometerModel<Clock> meter;
+++ auto&& result = Detail::complete_invoke(fun, Chronometer(meter, iters));
+++
+++ return { meter.elapsed(), CATCH_MOVE(result), iters };
+++ }
+++
+++ template <typename Clock, typename Fun>
+++ using run_for_at_least_argument_t = std::conditional_t<is_callable<Fun(Chronometer)>::value, Chronometer, int>;
+++
+++
+++ [[noreturn]]
+++ void throw_optimized_away_error();
+++
+++ template <typename Clock, typename Fun>
+++ TimingOf<Fun, run_for_at_least_argument_t<Clock, Fun>>
+++ run_for_at_least(IDuration how_long,
+++ const int initial_iterations,
+++ Fun&& fun) {
+++ auto iters = initial_iterations;
+++ while (iters < (1 << 30)) {
+++ auto&& Timing = measure_one<Clock>(fun, iters, is_callable<Fun(Chronometer)>());
+++
+++ if (Timing.elapsed >= how_long) {
+++ return { Timing.elapsed, CATCH_MOVE(Timing.result), iters };
+++ }
+++ iters *= 2;
+++ }
+++ throw_optimized_away_error();
+++ }
+++ } // namespace Detail
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_RUN_FOR_AT_LEAST_HPP_INCLUDED
+++
+++#include <vector>
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ struct ExecutionPlan {
+++ int iterations_per_sample;
+++ FDuration estimated_duration;
+++ Detail::BenchmarkFunction benchmark;
+++ FDuration warmup_time;
+++ int warmup_iterations;
+++
+++ template <typename Clock>
+++ std::vector<FDuration> run(const IConfig &cfg, Environment env) const {
+++ // warmup a bit
+++ Detail::run_for_at_least<Clock>(
+++ std::chrono::duration_cast<IDuration>( warmup_time ),
+++ warmup_iterations,
+++ Detail::repeat( []() { return Clock::now(); } )
+++ );
+++
+++ std::vector<FDuration> times;
+++ const auto num_samples = cfg.benchmarkSamples();
+++ times.reserve( num_samples );
+++ for ( size_t i = 0; i < num_samples; ++i ) {
+++ Detail::ChronometerModel<Clock> model;
+++ this->benchmark( Chronometer( model, iterations_per_sample ) );
+++ auto sample_time = model.elapsed() - env.clock_cost.mean;
+++ if ( sample_time < FDuration::zero() ) {
+++ sample_time = FDuration::zero();
+++ }
+++ times.push_back(sample_time / iterations_per_sample);
+++ }
+++ return times;
+++ }
+++ };
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_EXECUTION_PLAN_HPP_INCLUDED
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
+++#define CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
+++
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_STATS_HPP_INCLUDED
+++#define CATCH_STATS_HPP_INCLUDED
+++
+++
+++#include <vector>
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ namespace Detail {
+++ using sample = std::vector<double>;
+++
+++ double weighted_average_quantile( int k,
+++ int q,
+++ double* first,
+++ double* last );
+++
+++ OutlierClassification
+++ classify_outliers( double const* first, double const* last );
+++
+++ double mean( double const* first, double const* last );
+++
+++ double normal_cdf( double x );
+++
+++ double erfc_inv(double x);
+++
+++ double normal_quantile(double p);
+++
+++ Estimate<double>
+++ bootstrap( double confidence_level,
+++ double* first,
+++ double* last,
+++ sample const& resample,
+++ double ( *estimator )( double const*, double const* ) );
+++
+++ struct bootstrap_analysis {
+++ Estimate<double> mean;
+++ Estimate<double> standard_deviation;
+++ double outlier_variance;
+++ };
+++
+++ bootstrap_analysis analyse_samples(double confidence_level,
+++ unsigned int n_resamples,
+++ double* first,
+++ double* last);
+++ } // namespace Detail
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_STATS_HPP_INCLUDED
+++
+++#include <algorithm>
+++#include <vector>
+++#include <cmath>
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ namespace Detail {
+++ template <typename Clock>
+++ std::vector<double> resolution(int k) {
+++ std::vector<TimePoint<Clock>> times;
+++ times.reserve(static_cast<size_t>(k + 1));
+++ for ( int i = 0; i < k + 1; ++i ) {
+++ times.push_back( Clock::now() );
+++ }
+++
+++ std::vector<double> deltas;
+++ deltas.reserve(static_cast<size_t>(k));
+++ for ( size_t idx = 1; idx < times.size(); ++idx ) {
+++ deltas.push_back( static_cast<double>(
+++ ( times[idx] - times[idx - 1] ).count() ) );
+++ }
+++
+++ return deltas;
+++ }
+++
+++ constexpr auto warmup_iterations = 10000;
+++ constexpr auto warmup_time = std::chrono::milliseconds(100);
+++ constexpr auto minimum_ticks = 1000;
+++ constexpr auto warmup_seed = 10000;
+++ constexpr auto clock_resolution_estimation_time = std::chrono::milliseconds(500);
+++ constexpr auto clock_cost_estimation_time_limit = std::chrono::seconds(1);
+++ constexpr auto clock_cost_estimation_tick_limit = 100000;
+++ constexpr auto clock_cost_estimation_time = std::chrono::milliseconds(10);
+++ constexpr auto clock_cost_estimation_iterations = 10000;
+++
+++ template <typename Clock>
+++ int warmup() {
+++ return run_for_at_least<Clock>(warmup_time, warmup_seed, &resolution<Clock>)
+++ .iterations;
+++ }
+++ template <typename Clock>
+++ EnvironmentEstimate estimate_clock_resolution(int iterations) {
+++ auto r = run_for_at_least<Clock>(clock_resolution_estimation_time, iterations, &resolution<Clock>)
+++ .result;
+++ return {
+++ FDuration(mean(r.data(), r.data() + r.size())),
+++ classify_outliers(r.data(), r.data() + r.size()),
+++ };
+++ }
+++ template <typename Clock>
+++ EnvironmentEstimate estimate_clock_cost(FDuration resolution) {
+++ auto time_limit = (std::min)(
+++ resolution * clock_cost_estimation_tick_limit,
+++ FDuration(clock_cost_estimation_time_limit));
+++ auto time_clock = [](int k) {
+++ return Detail::measure<Clock>([k] {
+++ for (int i = 0; i < k; ++i) {
+++ volatile auto ignored = Clock::now();
+++ (void)ignored;
+++ }
+++ }).elapsed;
+++ };
+++ time_clock(1);
+++ int iters = clock_cost_estimation_iterations;
+++ auto&& r = run_for_at_least<Clock>(clock_cost_estimation_time, iters, time_clock);
+++ std::vector<double> times;
+++ int nsamples = static_cast<int>(std::ceil(time_limit / r.elapsed));
+++ times.reserve(static_cast<size_t>(nsamples));
+++ for ( int s = 0; s < nsamples; ++s ) {
+++ times.push_back( static_cast<double>(
+++ ( time_clock( r.iterations ) / r.iterations )
+++ .count() ) );
+++ }
+++ return {
+++ FDuration(mean(times.data(), times.data() + times.size())),
+++ classify_outliers(times.data(), times.data() + times.size()),
+++ };
+++ }
+++
+++ template <typename Clock>
+++ Environment measure_environment() {
+++#if defined(__clang__)
+++# pragma clang diagnostic push
+++# pragma clang diagnostic ignored "-Wexit-time-destructors"
+++#endif
+++ static Catch::Detail::unique_ptr<Environment> env;
+++#if defined(__clang__)
+++# pragma clang diagnostic pop
+++#endif
+++ if (env) {
+++ return *env;
+++ }
+++
+++ auto iters = Detail::warmup<Clock>();
+++ auto resolution = Detail::estimate_clock_resolution<Clock>(iters);
+++ auto cost = Detail::estimate_clock_cost<Clock>(resolution.mean);
+++
+++ env = Catch::Detail::make_unique<Environment>( Environment{resolution, cost} );
+++ return *env;
+++ }
+++ } // namespace Detail
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_ESTIMATE_CLOCK_HPP_INCLUDED
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_ANALYSE_HPP_INCLUDED
+++#define CATCH_ANALYSE_HPP_INCLUDED
+++
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
+++#define CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
+++
+++
+++#include <vector>
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ struct SampleAnalysis {
+++ std::vector<FDuration> samples;
+++ Estimate<FDuration> mean;
+++ Estimate<FDuration> standard_deviation;
+++ OutlierClassification outliers;
+++ double outlier_variance;
+++ };
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_SAMPLE_ANALYSIS_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++ class IConfig;
+++
+++ namespace Benchmark {
+++ namespace Detail {
+++ SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last);
+++ } // namespace Detail
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_ANALYSE_HPP_INCLUDED
+++
+++#include <algorithm>
+++#include <chrono>
+++#include <exception>
+++#include <string>
+++#include <cmath>
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ struct Benchmark {
+++ Benchmark(std::string&& benchmarkName)
+++ : name(CATCH_MOVE(benchmarkName)) {}
+++
+++ template <class FUN>
+++ Benchmark(std::string&& benchmarkName , FUN &&func)
+++ : fun(CATCH_MOVE(func)), name(CATCH_MOVE(benchmarkName)) {}
+++
+++ template <typename Clock>
+++ ExecutionPlan prepare(const IConfig &cfg, Environment env) const {
+++ auto min_time = env.clock_resolution.mean * Detail::minimum_ticks;
+++ auto run_time = std::max(min_time, std::chrono::duration_cast<decltype(min_time)>(cfg.benchmarkWarmupTime()));
+++ auto&& test = Detail::run_for_at_least<Clock>(std::chrono::duration_cast<IDuration>(run_time), 1, fun);
+++ int new_iters = static_cast<int>(std::ceil(min_time * test.iterations / test.elapsed));
+++ return { new_iters, test.elapsed / test.iterations * new_iters * cfg.benchmarkSamples(), fun, std::chrono::duration_cast<FDuration>(cfg.benchmarkWarmupTime()), Detail::warmup_iterations };
+++ }
+++
+++ template <typename Clock = default_clock>
+++ void run() {
+++ static_assert( Clock::is_steady,
+++ "Benchmarking clock should be steady" );
+++ auto const* cfg = getCurrentContext().getConfig();
+++
+++ auto env = Detail::measure_environment<Clock>();
+++
+++ getResultCapture().benchmarkPreparing(name);
+++ CATCH_TRY{
+++ auto plan = user_code([&] {
+++ return prepare<Clock>(*cfg, env);
+++ });
+++
+++ BenchmarkInfo info {
+++ CATCH_MOVE(name),
+++ plan.estimated_duration.count(),
+++ plan.iterations_per_sample,
+++ cfg->benchmarkSamples(),
+++ cfg->benchmarkResamples(),
+++ env.clock_resolution.mean.count(),
+++ env.clock_cost.mean.count()
+++ };
+++
+++ getResultCapture().benchmarkStarting(info);
+++
+++ auto samples = user_code([&] {
+++ return plan.template run<Clock>(*cfg, env);
+++ });
+++
+++ auto analysis = Detail::analyse(*cfg, samples.data(), samples.data() + samples.size());
+++ BenchmarkStats<> stats{ CATCH_MOVE(info), CATCH_MOVE(analysis.samples), analysis.mean, analysis.standard_deviation, analysis.outliers, analysis.outlier_variance };
+++ getResultCapture().benchmarkEnded(stats);
+++ } CATCH_CATCH_ANON (TestFailureException const&) {
+++ getResultCapture().benchmarkFailed("Benchmark failed due to failed assertion"_sr);
+++ } CATCH_CATCH_ALL{
+++ getResultCapture().benchmarkFailed(translateActiveException());
+++ // We let the exception go further up so that the
+++ // test case is marked as failed.
+++ std::rethrow_exception(std::current_exception());
+++ }
+++ }
+++
+++ // sets lambda to be used in fun *and* executes benchmark!
+++ template <typename Fun, std::enable_if_t<!Detail::is_related<Fun, Benchmark>::value, int> = 0>
+++ Benchmark & operator=(Fun func) {
+++ auto const* cfg = getCurrentContext().getConfig();
+++ if (!cfg->skipBenchmarks()) {
+++ fun = Detail::BenchmarkFunction(func);
+++ run();
+++ }
+++ return *this;
+++ }
+++
+++ explicit operator bool() {
+++ return true;
+++ }
+++
+++ private:
+++ Detail::BenchmarkFunction fun;
+++ std::string name;
+++ };
+++ }
+++} // namespace Catch
+++
+++#define INTERNAL_CATCH_GET_1_ARG(arg1, arg2, ...) arg1
+++#define INTERNAL_CATCH_GET_2_ARG(arg1, arg2, ...) arg2
+++
+++#define INTERNAL_CATCH_BENCHMARK(BenchmarkName, name, benchmarkIndex)\
+++ if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+++ BenchmarkName = [&](int benchmarkIndex)
+++
+++#define INTERNAL_CATCH_BENCHMARK_ADVANCED(BenchmarkName, name)\
+++ if( Catch::Benchmark::Benchmark BenchmarkName{name} ) \
+++ BenchmarkName = [&]
+++
+++#if defined(CATCH_CONFIG_PREFIX_ALL)
+++
+++#define CATCH_BENCHMARK(...) \
+++ INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+++#define CATCH_BENCHMARK_ADVANCED(name) \
+++ INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name)
+++
+++#else
+++
+++#define BENCHMARK(...) \
+++ INTERNAL_CATCH_BENCHMARK(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), INTERNAL_CATCH_GET_1_ARG(__VA_ARGS__,,), INTERNAL_CATCH_GET_2_ARG(__VA_ARGS__,,))
+++#define BENCHMARK_ADVANCED(name) \
+++ INTERNAL_CATCH_BENCHMARK_ADVANCED(INTERNAL_CATCH_UNIQUE_NAME(CATCH2_INTERNAL_BENCHMARK_), name)
+++
+++#endif
+++
+++#endif // CATCH_BENCHMARK_HPP_INCLUDED
+++
+++
+++// Adapted from donated nonius code.
+++
+++#ifndef CATCH_CONSTRUCTOR_HPP_INCLUDED
+++#define CATCH_CONSTRUCTOR_HPP_INCLUDED
+++
+++
+++#include <type_traits>
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ namespace Detail {
+++ template <typename T, bool Destruct>
+++ struct ObjectStorage
+++ {
+++ ObjectStorage() = default;
+++
+++ ObjectStorage(const ObjectStorage& other)
+++ {
+++ new(&data) T(other.stored_object());
+++ }
+++
+++ ObjectStorage(ObjectStorage&& other)
+++ {
+++ new(data) T(CATCH_MOVE(other.stored_object()));
+++ }
+++
+++ ~ObjectStorage() { destruct_on_exit<T>(); }
+++
+++ template <typename... Args>
+++ void construct(Args&&... args)
+++ {
+++ new (data) T(CATCH_FORWARD(args)...);
+++ }
+++
+++ template <bool AllowManualDestruction = !Destruct>
+++ std::enable_if_t<AllowManualDestruction> destruct()
+++ {
+++ stored_object().~T();
+++ }
+++
+++ private:
+++ // If this is a constructor benchmark, destruct the underlying object
+++ template <typename U>
+++ void destruct_on_exit(std::enable_if_t<Destruct, U>* = nullptr) { destruct<true>(); }
+++ // Otherwise, don't
+++ template <typename U>
+++ void destruct_on_exit(std::enable_if_t<!Destruct, U>* = nullptr) { }
+++
+++#if defined( __GNUC__ ) && __GNUC__ <= 6
+++# pragma GCC diagnostic push
+++# pragma GCC diagnostic ignored "-Wstrict-aliasing"
+++#endif
+++ T& stored_object() { return *reinterpret_cast<T*>( data ); }
+++
+++ T const& stored_object() const {
+++ return *reinterpret_cast<T const*>( data );
+++ }
+++#if defined( __GNUC__ ) && __GNUC__ <= 6
+++# pragma GCC diagnostic pop
+++#endif
+++
+++ alignas( T ) unsigned char data[sizeof( T )]{};
+++ };
+++ } // namespace Detail
+++
+++ template <typename T>
+++ using storage_for = Detail::ObjectStorage<T, true>;
+++
+++ template <typename T>
+++ using destructable_object = Detail::ObjectStorage<T, false>;
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++#endif // CATCH_CONSTRUCTOR_HPP_INCLUDED
+++
+++#endif // CATCH_BENCHMARK_ALL_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_APPROX_HPP_INCLUDED
+++#define CATCH_APPROX_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_TOSTRING_HPP_INCLUDED
+++#define CATCH_TOSTRING_HPP_INCLUDED
+++
+++
+++#include <vector>
+++#include <cstddef>
+++#include <type_traits>
+++#include <string>
+++
+++
+++
+++
+++/** \file
+++ * Wrapper for the WCHAR configuration option
+++ *
+++ * We want to support platforms that do not provide `wchar_t`, so we
+++ * sometimes have to disable providing wchar_t overloads through Catch2,
+++ * e.g. the StringMaker specialization for `std::wstring`.
+++ */
+++
+++#ifndef CATCH_CONFIG_WCHAR_HPP_INCLUDED
+++#define CATCH_CONFIG_WCHAR_HPP_INCLUDED
+++
+++
+++// We assume that WCHAR should be enabled by default, and only disabled
+++// for a shortlist (so far only DJGPP) of compilers.
+++
+++#if defined(__DJGPP__)
+++# define CATCH_INTERNAL_CONFIG_NO_WCHAR
+++#endif // __DJGPP__
+++
+++#if !defined( CATCH_INTERNAL_CONFIG_NO_WCHAR ) && \
+++ !defined( CATCH_CONFIG_NO_WCHAR ) && \
+++ !defined( CATCH_CONFIG_WCHAR )
+++# define CATCH_CONFIG_WCHAR
+++#endif
+++
+++#endif // CATCH_CONFIG_WCHAR_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
+++#define CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
+++
+++
+++#include <iosfwd>
+++#include <cstddef>
+++#include <ostream>
+++#include <string>
+++
+++namespace Catch {
+++
+++ class ReusableStringStream : Detail::NonCopyable {
+++ std::size_t m_index;
+++ std::ostream* m_oss;
+++ public:
+++ ReusableStringStream();
+++ ~ReusableStringStream();
+++
+++ //! Returns the serialized state
+++ std::string str() const;
+++ //! Sets internal state to `str`
+++ void str(std::string const& str);
+++
+++#if defined(__GNUC__) && !defined(__clang__)
+++#pragma GCC diagnostic push
+++// Old versions of GCC do not understand -Wnonnull-compare
+++#pragma GCC diagnostic ignored "-Wpragmas"
+++// Streaming a function pointer triggers Waddress and Wnonnull-compare
+++// on GCC, because it implicitly converts it to bool and then decides
+++// that the check it uses (a? true : false) is tautological and cannot
+++// be null...
+++#pragma GCC diagnostic ignored "-Waddress"
+++#pragma GCC diagnostic ignored "-Wnonnull-compare"
+++#endif
+++
+++ template<typename T>
+++ auto operator << ( T const& value ) -> ReusableStringStream& {
+++ *m_oss << value;
+++ return *this;
+++ }
+++
+++#if defined(__GNUC__) && !defined(__clang__)
+++#pragma GCC diagnostic pop
+++#endif
+++ auto get() -> std::ostream& { return *m_oss; }
+++ };
+++}
+++
+++#endif // CATCH_REUSABLE_STRING_STREAM_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_VOID_TYPE_HPP_INCLUDED
+++#define CATCH_VOID_TYPE_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++ namespace Detail {
+++
+++ template <typename...>
+++ struct make_void { using type = void; };
+++
+++ template <typename... Ts>
+++ using void_t = typename make_void<Ts...>::type;
+++
+++ } // namespace Detail
+++} // namespace Catch
+++
+++
+++#endif // CATCH_VOID_TYPE_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+++#define CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+++
+++
+++#include <vector>
+++
+++namespace Catch {
+++
+++ namespace Detail {
+++ struct EnumInfo {
+++ StringRef m_name;
+++ std::vector<std::pair<int, StringRef>> m_values;
+++
+++ ~EnumInfo();
+++
+++ StringRef lookup( int value ) const;
+++ };
+++ } // namespace Detail
+++
+++ class IMutableEnumValuesRegistry {
+++ public:
+++ virtual ~IMutableEnumValuesRegistry(); // = default;
+++
+++ virtual Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::vector<int> const& values ) = 0;
+++
+++ template<typename E>
+++ Detail::EnumInfo const& registerEnum( StringRef enumName, StringRef allEnums, std::initializer_list<E> values ) {
+++ static_assert(sizeof(int) >= sizeof(E), "Cannot serialize enum to int");
+++ std::vector<int> intValues;
+++ intValues.reserve( values.size() );
+++ for( auto enumValue : values )
+++ intValues.push_back( static_cast<int>( enumValue ) );
+++ return registerEnum( enumName, allEnums, intValues );
+++ }
+++ };
+++
+++} // Catch
+++
+++#endif // CATCH_INTERFACES_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+++
+++#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+++#include <string_view>
+++#endif
+++
+++#ifdef _MSC_VER
+++#pragma warning(push)
+++#pragma warning(disable:4180) // We attempt to stream a function (address) by const&, which MSVC complains about but is harmless
+++#endif
+++
+++// We need a dummy global operator<< so we can bring it into Catch namespace later
+++struct Catch_global_namespace_dummy{};
+++std::ostream& operator<<(std::ostream&, Catch_global_namespace_dummy);
+++
+++namespace Catch {
+++ // Bring in global namespace operator<< for ADL lookup in
+++ // `IsStreamInsertable` below.
+++ using ::operator<<;
+++
+++ namespace Detail {
+++
+++ inline std::size_t catch_strnlen(const char *str, std::size_t n) {
+++ auto ret = std::char_traits<char>::find(str, n, '\0');
+++ if (ret != nullptr) {
+++ return static_cast<std::size_t>(ret - str);
+++ }
+++ return n;
+++ }
+++
+++ constexpr StringRef unprintableString = "{?}"_sr;
+++
+++ //! Encases `string in quotes, and optionally escapes invisibles
+++ std::string convertIntoString( StringRef string, bool escapeInvisibles );
+++
+++ //! Encases `string` in quotes, and escapes invisibles if user requested
+++ //! it via CLI
+++ std::string convertIntoString( StringRef string );
+++
+++ std::string rawMemoryToString( const void *object, std::size_t size );
+++
+++ template<typename T>
+++ std::string rawMemoryToString( const T& object ) {
+++ return rawMemoryToString( &object, sizeof(object) );
+++ }
+++
+++ template<typename T>
+++ class IsStreamInsertable {
+++ template<typename Stream, typename U>
+++ static auto test(int)
+++ -> decltype(std::declval<Stream&>() << std::declval<U>(), std::true_type());
+++
+++ template<typename, typename>
+++ static auto test(...)->std::false_type;
+++
+++ public:
+++ static const bool value = decltype(test<std::ostream, const T&>(0))::value;
+++ };
+++
+++ template<typename E>
+++ std::string convertUnknownEnumToString( E e );
+++
+++ template<typename T>
+++ std::enable_if_t<
+++ !std::is_enum<T>::value && !std::is_base_of<std::exception, T>::value,
+++ std::string> convertUnstreamable( T const& ) {
+++ return std::string(Detail::unprintableString);
+++ }
+++ template<typename T>
+++ std::enable_if_t<
+++ !std::is_enum<T>::value && std::is_base_of<std::exception, T>::value,
+++ std::string> convertUnstreamable(T const& ex) {
+++ return ex.what();
+++ }
+++
+++
+++ template<typename T>
+++ std::enable_if_t<
+++ std::is_enum<T>::value,
+++ std::string> convertUnstreamable( T const& value ) {
+++ return convertUnknownEnumToString( value );
+++ }
+++
+++#if defined(_MANAGED)
+++ //! Convert a CLR string to a utf8 std::string
+++ template<typename T>
+++ std::string clrReferenceToString( T^ ref ) {
+++ if (ref == nullptr)
+++ return std::string("null");
+++ auto bytes = System::Text::Encoding::UTF8->GetBytes(ref->ToString());
+++ cli::pin_ptr<System::Byte> p = &bytes[0];
+++ return std::string(reinterpret_cast<char const *>(p), bytes->Length);
+++ }
+++#endif
+++
+++ } // namespace Detail
+++
+++
+++ template <typename T, typename = void>
+++ struct StringMaker {
+++ template <typename Fake = T>
+++ static
+++ std::enable_if_t<::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
+++ convert(const Fake& value) {
+++ ReusableStringStream rss;
+++ // NB: call using the function-like syntax to avoid ambiguity with
+++ // user-defined templated operator<< under clang.
+++ rss.operator<<(value);
+++ return rss.str();
+++ }
+++
+++ template <typename Fake = T>
+++ static
+++ std::enable_if_t<!::Catch::Detail::IsStreamInsertable<Fake>::value, std::string>
+++ convert( const Fake& value ) {
+++#if !defined(CATCH_CONFIG_FALLBACK_STRINGIFIER)
+++ return Detail::convertUnstreamable(value);
+++#else
+++ return CATCH_CONFIG_FALLBACK_STRINGIFIER(value);
+++#endif
+++ }
+++ };
+++
+++ namespace Detail {
+++
+++ // This function dispatches all stringification requests inside of Catch.
+++ // Should be preferably called fully qualified, like ::Catch::Detail::stringify
+++ template <typename T>
+++ std::string stringify(const T& e) {
+++ return ::Catch::StringMaker<std::remove_cv_t<std::remove_reference_t<T>>>::convert(e);
+++ }
+++
+++ template<typename E>
+++ std::string convertUnknownEnumToString( E e ) {
+++ return ::Catch::Detail::stringify(static_cast<std::underlying_type_t<E>>(e));
+++ }
+++
+++#if defined(_MANAGED)
+++ template <typename T>
+++ std::string stringify( T^ e ) {
+++ return ::Catch::StringMaker<T^>::convert(e);
+++ }
+++#endif
+++
+++ } // namespace Detail
+++
+++ // Some predefined specializations
+++
+++ template<>
+++ struct StringMaker<std::string> {
+++ static std::string convert(const std::string& str);
+++ };
+++
+++#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+++ template<>
+++ struct StringMaker<std::string_view> {
+++ static std::string convert(std::string_view str);
+++ };
+++#endif
+++
+++ template<>
+++ struct StringMaker<char const *> {
+++ static std::string convert(char const * str);
+++ };
+++ template<>
+++ struct StringMaker<char *> {
+++ static std::string convert(char * str);
+++ };
+++
+++#if defined(CATCH_CONFIG_WCHAR)
+++ template<>
+++ struct StringMaker<std::wstring> {
+++ static std::string convert(const std::wstring& wstr);
+++ };
+++
+++# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+++ template<>
+++ struct StringMaker<std::wstring_view> {
+++ static std::string convert(std::wstring_view str);
+++ };
+++# endif
+++
+++ template<>
+++ struct StringMaker<wchar_t const *> {
+++ static std::string convert(wchar_t const * str);
+++ };
+++ template<>
+++ struct StringMaker<wchar_t *> {
+++ static std::string convert(wchar_t * str);
+++ };
+++#endif // CATCH_CONFIG_WCHAR
+++
+++ template<size_t SZ>
+++ struct StringMaker<char[SZ]> {
+++ static std::string convert(char const* str) {
+++ return Detail::convertIntoString(
+++ StringRef( str, Detail::catch_strnlen( str, SZ ) ) );
+++ }
+++ };
+++ template<size_t SZ>
+++ struct StringMaker<signed char[SZ]> {
+++ static std::string convert(signed char const* str) {
+++ auto reinterpreted = reinterpret_cast<char const*>(str);
+++ return Detail::convertIntoString(
+++ StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
+++ }
+++ };
+++ template<size_t SZ>
+++ struct StringMaker<unsigned char[SZ]> {
+++ static std::string convert(unsigned char const* str) {
+++ auto reinterpreted = reinterpret_cast<char const*>(str);
+++ return Detail::convertIntoString(
+++ StringRef(reinterpreted, Detail::catch_strnlen(reinterpreted, SZ)));
+++ }
+++ };
+++
+++#if defined(CATCH_CONFIG_CPP17_BYTE)
+++ template<>
+++ struct StringMaker<std::byte> {
+++ static std::string convert(std::byte value);
+++ };
+++#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+++ template<>
+++ struct StringMaker<int> {
+++ static std::string convert(int value);
+++ };
+++ template<>
+++ struct StringMaker<long> {
+++ static std::string convert(long value);
+++ };
+++ template<>
+++ struct StringMaker<long long> {
+++ static std::string convert(long long value);
+++ };
+++ template<>
+++ struct StringMaker<unsigned int> {
+++ static std::string convert(unsigned int value);
+++ };
+++ template<>
+++ struct StringMaker<unsigned long> {
+++ static std::string convert(unsigned long value);
+++ };
+++ template<>
+++ struct StringMaker<unsigned long long> {
+++ static std::string convert(unsigned long long value);
+++ };
+++
+++ template<>
+++ struct StringMaker<bool> {
+++ static std::string convert(bool b) {
+++ using namespace std::string_literals;
+++ return b ? "true"s : "false"s;
+++ }
+++ };
+++
+++ template<>
+++ struct StringMaker<char> {
+++ static std::string convert(char c);
+++ };
+++ template<>
+++ struct StringMaker<signed char> {
+++ static std::string convert(signed char value);
+++ };
+++ template<>
+++ struct StringMaker<unsigned char> {
+++ static std::string convert(unsigned char value);
+++ };
+++
+++ template<>
+++ struct StringMaker<std::nullptr_t> {
+++ static std::string convert(std::nullptr_t) {
+++ using namespace std::string_literals;
+++ return "nullptr"s;
+++ }
+++ };
+++
+++ template<>
+++ struct StringMaker<float> {
+++ static std::string convert(float value);
+++ CATCH_EXPORT static int precision;
+++ };
+++
+++ template<>
+++ struct StringMaker<double> {
+++ static std::string convert(double value);
+++ CATCH_EXPORT static int precision;
+++ };
+++
+++ template <typename T>
+++ struct StringMaker<T*> {
+++ template <typename U>
+++ static std::string convert(U* p) {
+++ if (p) {
+++ return ::Catch::Detail::rawMemoryToString(p);
+++ } else {
+++ return "nullptr";
+++ }
+++ }
+++ };
+++
+++ template <typename R, typename C>
+++ struct StringMaker<R C::*> {
+++ static std::string convert(R C::* p) {
+++ if (p) {
+++ return ::Catch::Detail::rawMemoryToString(p);
+++ } else {
+++ return "nullptr";
+++ }
+++ }
+++ };
+++
+++#if defined(_MANAGED)
+++ template <typename T>
+++ struct StringMaker<T^> {
+++ static std::string convert( T^ ref ) {
+++ return ::Catch::Detail::clrReferenceToString(ref);
+++ }
+++ };
+++#endif
+++
+++ namespace Detail {
+++ template<typename InputIterator, typename Sentinel = InputIterator>
+++ std::string rangeToString(InputIterator first, Sentinel last) {
+++ ReusableStringStream rss;
+++ rss << "{ ";
+++ if (first != last) {
+++ rss << ::Catch::Detail::stringify(*first);
+++ for (++first; first != last; ++first)
+++ rss << ", " << ::Catch::Detail::stringify(*first);
+++ }
+++ rss << " }";
+++ return rss.str();
+++ }
+++ }
+++
+++} // namespace Catch
+++
+++//////////////////////////////////////////////////////
+++// Separate std-lib types stringification, so it can be selectively enabled
+++// This means that we do not bring in their headers
+++
+++#if defined(CATCH_CONFIG_ENABLE_ALL_STRINGMAKERS)
+++# define CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+++# define CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+++# define CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+++# define CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+++#endif
+++
+++// Separate std::pair specialization
+++#if defined(CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER)
+++#include <utility>
+++namespace Catch {
+++ template<typename T1, typename T2>
+++ struct StringMaker<std::pair<T1, T2> > {
+++ static std::string convert(const std::pair<T1, T2>& pair) {
+++ ReusableStringStream rss;
+++ rss << "{ "
+++ << ::Catch::Detail::stringify(pair.first)
+++ << ", "
+++ << ::Catch::Detail::stringify(pair.second)
+++ << " }";
+++ return rss.str();
+++ }
+++ };
+++}
+++#endif // CATCH_CONFIG_ENABLE_PAIR_STRINGMAKER
+++
+++#if defined(CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_OPTIONAL)
+++#include <optional>
+++namespace Catch {
+++ template<typename T>
+++ struct StringMaker<std::optional<T> > {
+++ static std::string convert(const std::optional<T>& optional) {
+++ if (optional.has_value()) {
+++ return ::Catch::Detail::stringify(*optional);
+++ } else {
+++ return "{ }";
+++ }
+++ }
+++ };
+++ template <>
+++ struct StringMaker<std::nullopt_t> {
+++ static std::string convert(const std::nullopt_t&) {
+++ return "{ }";
+++ }
+++ };
+++}
+++#endif // CATCH_CONFIG_ENABLE_OPTIONAL_STRINGMAKER
+++
+++// Separate std::tuple specialization
+++#if defined(CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER)
+++#include <tuple>
+++namespace Catch {
+++ namespace Detail {
+++ template<
+++ typename Tuple,
+++ std::size_t N = 0,
+++ bool = (N < std::tuple_size<Tuple>::value)
+++ >
+++ struct TupleElementPrinter {
+++ static void print(const Tuple& tuple, std::ostream& os) {
+++ os << (N ? ", " : " ")
+++ << ::Catch::Detail::stringify(std::get<N>(tuple));
+++ TupleElementPrinter<Tuple, N + 1>::print(tuple, os);
+++ }
+++ };
+++
+++ template<
+++ typename Tuple,
+++ std::size_t N
+++ >
+++ struct TupleElementPrinter<Tuple, N, false> {
+++ static void print(const Tuple&, std::ostream&) {}
+++ };
+++
+++ }
+++
+++
+++ template<typename ...Types>
+++ struct StringMaker<std::tuple<Types...>> {
+++ static std::string convert(const std::tuple<Types...>& tuple) {
+++ ReusableStringStream rss;
+++ rss << '{';
+++ Detail::TupleElementPrinter<std::tuple<Types...>>::print(tuple, rss.get());
+++ rss << " }";
+++ return rss.str();
+++ }
+++ };
+++}
+++#endif // CATCH_CONFIG_ENABLE_TUPLE_STRINGMAKER
+++
+++#if defined(CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER) && defined(CATCH_CONFIG_CPP17_VARIANT)
+++#include <variant>
+++namespace Catch {
+++ template<>
+++ struct StringMaker<std::monostate> {
+++ static std::string convert(const std::monostate&) {
+++ return "{ }";
+++ }
+++ };
+++
+++ template<typename... Elements>
+++ struct StringMaker<std::variant<Elements...>> {
+++ static std::string convert(const std::variant<Elements...>& variant) {
+++ if (variant.valueless_by_exception()) {
+++ return "{valueless variant}";
+++ } else {
+++ return std::visit(
+++ [](const auto& value) {
+++ return ::Catch::Detail::stringify(value);
+++ },
+++ variant
+++ );
+++ }
+++ }
+++ };
+++}
+++#endif // CATCH_CONFIG_ENABLE_VARIANT_STRINGMAKER
+++
+++namespace Catch {
+++ // Import begin/ end from std here
+++ using std::begin;
+++ using std::end;
+++
+++ namespace Detail {
+++ template <typename T, typename = void>
+++ struct is_range_impl : std::false_type {};
+++
+++ template <typename T>
+++ struct is_range_impl<T, void_t<decltype(begin(std::declval<T>()))>> : std::true_type {};
+++ } // namespace Detail
+++
+++ template <typename T>
+++ struct is_range : Detail::is_range_impl<T> {};
+++
+++#if defined(_MANAGED) // Managed types are never ranges
+++ template <typename T>
+++ struct is_range<T^> {
+++ static const bool value = false;
+++ };
+++#endif
+++
+++ template<typename Range>
+++ std::string rangeToString( Range const& range ) {
+++ return ::Catch::Detail::rangeToString( begin( range ), end( range ) );
+++ }
+++
+++ // Handle vector<bool> specially
+++ template<typename Allocator>
+++ std::string rangeToString( std::vector<bool, Allocator> const& v ) {
+++ ReusableStringStream rss;
+++ rss << "{ ";
+++ bool first = true;
+++ for( bool b : v ) {
+++ if( first )
+++ first = false;
+++ else
+++ rss << ", ";
+++ rss << ::Catch::Detail::stringify( b );
+++ }
+++ rss << " }";
+++ return rss.str();
+++ }
+++
+++ template<typename R>
+++ struct StringMaker<R, std::enable_if_t<is_range<R>::value && !::Catch::Detail::IsStreamInsertable<R>::value>> {
+++ static std::string convert( R const& range ) {
+++ return rangeToString( range );
+++ }
+++ };
+++
+++ template <typename T, size_t SZ>
+++ struct StringMaker<T[SZ]> {
+++ static std::string convert(T const(&arr)[SZ]) {
+++ return rangeToString(arr);
+++ }
+++ };
+++
+++
+++} // namespace Catch
+++
+++// Separate std::chrono::duration specialization
+++#include <ctime>
+++#include <ratio>
+++#include <chrono>
+++
+++
+++namespace Catch {
+++
+++template <class Ratio>
+++struct ratio_string {
+++ static std::string symbol() {
+++ Catch::ReusableStringStream rss;
+++ rss << '[' << Ratio::num << '/'
+++ << Ratio::den << ']';
+++ return rss.str();
+++ }
+++};
+++
+++template <>
+++struct ratio_string<std::atto> {
+++ static char symbol() { return 'a'; }
+++};
+++template <>
+++struct ratio_string<std::femto> {
+++ static char symbol() { return 'f'; }
+++};
+++template <>
+++struct ratio_string<std::pico> {
+++ static char symbol() { return 'p'; }
+++};
+++template <>
+++struct ratio_string<std::nano> {
+++ static char symbol() { return 'n'; }
+++};
+++template <>
+++struct ratio_string<std::micro> {
+++ static char symbol() { return 'u'; }
+++};
+++template <>
+++struct ratio_string<std::milli> {
+++ static char symbol() { return 'm'; }
+++};
+++
+++ ////////////
+++ // std::chrono::duration specializations
+++ template<typename Value, typename Ratio>
+++ struct StringMaker<std::chrono::duration<Value, Ratio>> {
+++ static std::string convert(std::chrono::duration<Value, Ratio> const& duration) {
+++ ReusableStringStream rss;
+++ rss << duration.count() << ' ' << ratio_string<Ratio>::symbol() << 's';
+++ return rss.str();
+++ }
+++ };
+++ template<typename Value>
+++ struct StringMaker<std::chrono::duration<Value, std::ratio<1>>> {
+++ static std::string convert(std::chrono::duration<Value, std::ratio<1>> const& duration) {
+++ ReusableStringStream rss;
+++ rss << duration.count() << " s";
+++ return rss.str();
+++ }
+++ };
+++ template<typename Value>
+++ struct StringMaker<std::chrono::duration<Value, std::ratio<60>>> {
+++ static std::string convert(std::chrono::duration<Value, std::ratio<60>> const& duration) {
+++ ReusableStringStream rss;
+++ rss << duration.count() << " m";
+++ return rss.str();
+++ }
+++ };
+++ template<typename Value>
+++ struct StringMaker<std::chrono::duration<Value, std::ratio<3600>>> {
+++ static std::string convert(std::chrono::duration<Value, std::ratio<3600>> const& duration) {
+++ ReusableStringStream rss;
+++ rss << duration.count() << " h";
+++ return rss.str();
+++ }
+++ };
+++
+++ ////////////
+++ // std::chrono::time_point specialization
+++ // Generic time_point cannot be specialized, only std::chrono::time_point<system_clock>
+++ template<typename Clock, typename Duration>
+++ struct StringMaker<std::chrono::time_point<Clock, Duration>> {
+++ static std::string convert(std::chrono::time_point<Clock, Duration> const& time_point) {
+++ return ::Catch::Detail::stringify(time_point.time_since_epoch()) + " since epoch";
+++ }
+++ };
+++ // std::chrono::time_point<system_clock> specialization
+++ template<typename Duration>
+++ struct StringMaker<std::chrono::time_point<std::chrono::system_clock, Duration>> {
+++ static std::string convert(std::chrono::time_point<std::chrono::system_clock, Duration> const& time_point) {
+++ auto converted = std::chrono::system_clock::to_time_t(time_point);
+++
+++#ifdef _MSC_VER
+++ std::tm timeInfo = {};
+++ gmtime_s(&timeInfo, &converted);
+++#else
+++ std::tm* timeInfo = std::gmtime(&converted);
+++#endif
+++
+++ auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+++ char timeStamp[timeStampSize];
+++ const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+++
+++#ifdef _MSC_VER
+++ std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+++#else
+++ std::strftime(timeStamp, timeStampSize, fmt, timeInfo);
+++#endif
+++ return std::string(timeStamp, timeStampSize - 1);
+++ }
+++ };
+++}
+++
+++
+++#define INTERNAL_CATCH_REGISTER_ENUM( enumName, ... ) \
+++namespace Catch { \
+++ template<> struct StringMaker<enumName> { \
+++ static std::string convert( enumName value ) { \
+++ static const auto& enumInfo = ::Catch::getMutableRegistryHub().getMutableEnumValuesRegistry().registerEnum( #enumName, #__VA_ARGS__, { __VA_ARGS__ } ); \
+++ return static_cast<std::string>(enumInfo.lookup( static_cast<int>( value ) )); \
+++ } \
+++ }; \
+++}
+++
+++#define CATCH_REGISTER_ENUM( enumName, ... ) INTERNAL_CATCH_REGISTER_ENUM( enumName, __VA_ARGS__ )
+++
+++#ifdef _MSC_VER
+++#pragma warning(pop)
+++#endif
+++
+++#endif // CATCH_TOSTRING_HPP_INCLUDED
+++
+++#include <type_traits>
+++
+++namespace Catch {
+++
+++ class Approx {
+++ private:
+++ bool equalityComparisonImpl(double other) const;
+++ // Sets and validates the new margin (margin >= 0)
+++ void setMargin(double margin);
+++ // Sets and validates the new epsilon (0 < epsilon < 1)
+++ void setEpsilon(double epsilon);
+++
+++ public:
+++ explicit Approx ( double value );
+++
+++ static Approx custom();
+++
+++ Approx operator-() const;
+++
+++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+++ Approx operator()( T const& value ) const {
+++ Approx approx( static_cast<double>(value) );
+++ approx.m_epsilon = m_epsilon;
+++ approx.m_margin = m_margin;
+++ approx.m_scale = m_scale;
+++ return approx;
+++ }
+++
+++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+++ explicit Approx( T const& value ): Approx(static_cast<double>(value))
+++ {}
+++
+++
+++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+++ friend bool operator == ( const T& lhs, Approx const& rhs ) {
+++ auto lhs_v = static_cast<double>(lhs);
+++ return rhs.equalityComparisonImpl(lhs_v);
+++ }
+++
+++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+++ friend bool operator == ( Approx const& lhs, const T& rhs ) {
+++ return operator==( rhs, lhs );
+++ }
+++
+++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+++ friend bool operator != ( T const& lhs, Approx const& rhs ) {
+++ return !operator==( lhs, rhs );
+++ }
+++
+++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+++ friend bool operator != ( Approx const& lhs, T const& rhs ) {
+++ return !operator==( rhs, lhs );
+++ }
+++
+++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+++ friend bool operator <= ( T const& lhs, Approx const& rhs ) {
+++ return static_cast<double>(lhs) < rhs.m_value || lhs == rhs;
+++ }
+++
+++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+++ friend bool operator <= ( Approx const& lhs, T const& rhs ) {
+++ return lhs.m_value < static_cast<double>(rhs) || lhs == rhs;
+++ }
+++
+++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+++ friend bool operator >= ( T const& lhs, Approx const& rhs ) {
+++ return static_cast<double>(lhs) > rhs.m_value || lhs == rhs;
+++ }
+++
+++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+++ friend bool operator >= ( Approx const& lhs, T const& rhs ) {
+++ return lhs.m_value > static_cast<double>(rhs) || lhs == rhs;
+++ }
+++
+++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+++ Approx& epsilon( T const& newEpsilon ) {
+++ const auto epsilonAsDouble = static_cast<double>(newEpsilon);
+++ setEpsilon(epsilonAsDouble);
+++ return *this;
+++ }
+++
+++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+++ Approx& margin( T const& newMargin ) {
+++ const auto marginAsDouble = static_cast<double>(newMargin);
+++ setMargin(marginAsDouble);
+++ return *this;
+++ }
+++
+++ template <typename T, typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+++ Approx& scale( T const& newScale ) {
+++ m_scale = static_cast<double>(newScale);
+++ return *this;
+++ }
+++
+++ std::string toString() const;
+++
+++ private:
+++ double m_epsilon;
+++ double m_margin;
+++ double m_scale;
+++ double m_value;
+++ };
+++
+++namespace literals {
+++ Approx operator ""_a(long double val);
+++ Approx operator ""_a(unsigned long long val);
+++} // end namespace literals
+++
+++template<>
+++struct StringMaker<Catch::Approx> {
+++ static std::string convert(Catch::Approx const& value);
+++};
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_APPROX_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_ASSERTION_INFO_HPP_INCLUDED
+++#define CATCH_ASSERTION_INFO_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
+++#define CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
+++
+++#include <cstddef>
+++#include <iosfwd>
+++
+++namespace Catch {
+++
+++ struct SourceLineInfo {
+++
+++ SourceLineInfo() = delete;
+++ constexpr SourceLineInfo( char const* _file, std::size_t _line ) noexcept:
+++ file( _file ),
+++ line( _line )
+++ {}
+++
+++ bool operator == ( SourceLineInfo const& other ) const noexcept;
+++ bool operator < ( SourceLineInfo const& other ) const noexcept;
+++
+++ char const* file;
+++ std::size_t line;
+++
+++ friend std::ostream& operator << (std::ostream& os, SourceLineInfo const& info);
+++ };
+++}
+++
+++#define CATCH_INTERNAL_LINEINFO \
+++ ::Catch::SourceLineInfo( __FILE__, static_cast<std::size_t>( __LINE__ ) )
+++
+++#endif // CATCH_SOURCE_LINE_INFO_HPP_INCLUDED
+++
+++namespace Catch {
+++
+++ struct AssertionInfo {
+++ // AssertionInfo() = delete;
+++
+++ StringRef macroName;
+++ SourceLineInfo lineInfo;
+++ StringRef capturedExpression;
+++ ResultDisposition::Flags resultDisposition;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_ASSERTION_INFO_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_ASSERTION_RESULT_HPP_INCLUDED
+++#define CATCH_ASSERTION_RESULT_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_LAZY_EXPR_HPP_INCLUDED
+++#define CATCH_LAZY_EXPR_HPP_INCLUDED
+++
+++#include <iosfwd>
+++
+++namespace Catch {
+++
+++ class ITransientExpression;
+++
+++ class LazyExpression {
+++ friend class AssertionHandler;
+++ friend struct AssertionStats;
+++ friend class RunContext;
+++
+++ ITransientExpression const* m_transientExpression = nullptr;
+++ bool m_isNegated;
+++ public:
+++ LazyExpression( bool isNegated ):
+++ m_isNegated(isNegated)
+++ {}
+++ LazyExpression(LazyExpression const& other) = default;
+++ LazyExpression& operator = ( LazyExpression const& ) = delete;
+++
+++ explicit operator bool() const {
+++ return m_transientExpression != nullptr;
+++ }
+++
+++ friend auto operator << ( std::ostream& os, LazyExpression const& lazyExpr ) -> std::ostream&;
+++ };
+++
+++} // namespace Catch
+++
+++#endif // CATCH_LAZY_EXPR_HPP_INCLUDED
+++
+++#include <string>
+++
+++namespace Catch {
+++
+++ struct AssertionResultData
+++ {
+++ AssertionResultData() = delete;
+++
+++ AssertionResultData( ResultWas::OfType _resultType, LazyExpression const& _lazyExpression );
+++
+++ std::string message;
+++ mutable std::string reconstructedExpression;
+++ LazyExpression lazyExpression;
+++ ResultWas::OfType resultType;
+++
+++ std::string reconstructExpression() const;
+++ };
+++
+++ class AssertionResult {
+++ public:
+++ AssertionResult() = delete;
+++ AssertionResult( AssertionInfo const& info, AssertionResultData&& data );
+++
+++ bool isOk() const;
+++ bool succeeded() const;
+++ ResultWas::OfType getResultType() const;
+++ bool hasExpression() const;
+++ bool hasMessage() const;
+++ std::string getExpression() const;
+++ std::string getExpressionInMacro() const;
+++ bool hasExpandedExpression() const;
+++ std::string getExpandedExpression() const;
+++ StringRef getMessage() const;
+++ SourceLineInfo getSourceInfo() const;
+++ StringRef getTestMacroName() const;
+++
+++ //protected:
+++ AssertionInfo m_info;
+++ AssertionResultData m_resultData;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_ASSERTION_RESULT_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_CONFIG_HPP_INCLUDED
+++#define CATCH_CONFIG_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_TEST_SPEC_HPP_INCLUDED
+++#define CATCH_TEST_SPEC_HPP_INCLUDED
+++
+++#ifdef __clang__
+++#pragma clang diagnostic push
+++#pragma clang diagnostic ignored "-Wpadded"
+++#endif
+++
+++
+++
+++#ifndef CATCH_WILDCARD_PATTERN_HPP_INCLUDED
+++#define CATCH_WILDCARD_PATTERN_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_CASE_SENSITIVE_HPP_INCLUDED
+++#define CATCH_CASE_SENSITIVE_HPP_INCLUDED
+++
+++namespace Catch {
+++
+++ enum class CaseSensitive { Yes, No };
+++
+++} // namespace Catch
+++
+++#endif // CATCH_CASE_SENSITIVE_HPP_INCLUDED
+++
+++#include <string>
+++
+++namespace Catch
+++{
+++ class WildcardPattern {
+++ enum WildcardPosition {
+++ NoWildcard = 0,
+++ WildcardAtStart = 1,
+++ WildcardAtEnd = 2,
+++ WildcardAtBothEnds = WildcardAtStart | WildcardAtEnd
+++ };
+++
+++ public:
+++
+++ WildcardPattern( std::string const& pattern, CaseSensitive caseSensitivity );
+++ bool matches( std::string const& str ) const;
+++
+++ private:
+++ std::string normaliseString( std::string const& str ) const;
+++ CaseSensitive m_caseSensitivity;
+++ WildcardPosition m_wildcard = NoWildcard;
+++ std::string m_pattern;
+++ };
+++}
+++
+++#endif // CATCH_WILDCARD_PATTERN_HPP_INCLUDED
+++
+++#include <iosfwd>
+++#include <string>
+++#include <vector>
+++
+++namespace Catch {
+++
+++ class IConfig;
+++ struct TestCaseInfo;
+++ class TestCaseHandle;
+++
+++ class TestSpec {
+++
+++ class Pattern {
+++ public:
+++ explicit Pattern( std::string const& name );
+++ virtual ~Pattern();
+++ virtual bool matches( TestCaseInfo const& testCase ) const = 0;
+++ std::string const& name() const;
+++ private:
+++ virtual void serializeTo( std::ostream& out ) const = 0;
+++ // Writes string that would be reparsed into the pattern
+++ friend std::ostream& operator<<(std::ostream& out,
+++ Pattern const& pattern) {
+++ pattern.serializeTo( out );
+++ return out;
+++ }
+++
+++ std::string const m_name;
+++ };
+++
+++ class NamePattern : public Pattern {
+++ public:
+++ explicit NamePattern( std::string const& name, std::string const& filterString );
+++ bool matches( TestCaseInfo const& testCase ) const override;
+++ private:
+++ void serializeTo( std::ostream& out ) const override;
+++
+++ WildcardPattern m_wildcardPattern;
+++ };
+++
+++ class TagPattern : public Pattern {
+++ public:
+++ explicit TagPattern( std::string const& tag, std::string const& filterString );
+++ bool matches( TestCaseInfo const& testCase ) const override;
+++ private:
+++ void serializeTo( std::ostream& out ) const override;
+++
+++ std::string m_tag;
+++ };
+++
+++ struct Filter {
+++ std::vector<Detail::unique_ptr<Pattern>> m_required;
+++ std::vector<Detail::unique_ptr<Pattern>> m_forbidden;
+++
+++ //! Serializes this filter into a string that would be parsed into
+++ //! an equivalent filter
+++ void serializeTo( std::ostream& out ) const;
+++ friend std::ostream& operator<<(std::ostream& out, Filter const& f) {
+++ f.serializeTo( out );
+++ return out;
+++ }
+++
+++ bool matches( TestCaseInfo const& testCase ) const;
+++ };
+++
+++ static std::string extractFilterName( Filter const& filter );
+++
+++ public:
+++ struct FilterMatch {
+++ std::string name;
+++ std::vector<TestCaseHandle const*> tests;
+++ };
+++ using Matches = std::vector<FilterMatch>;
+++ using vectorStrings = std::vector<std::string>;
+++
+++ bool hasFilters() const;
+++ bool matches( TestCaseInfo const& testCase ) const;
+++ Matches matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const;
+++ const vectorStrings & getInvalidSpecs() const;
+++
+++ private:
+++ std::vector<Filter> m_filters;
+++ std::vector<std::string> m_invalidSpecs;
+++
+++ friend class TestSpecParser;
+++ //! Serializes this test spec into a string that would be parsed into
+++ //! equivalent test spec
+++ void serializeTo( std::ostream& out ) const;
+++ friend std::ostream& operator<<(std::ostream& out,
+++ TestSpec const& spec) {
+++ spec.serializeTo( out );
+++ return out;
+++ }
+++ };
+++}
+++
+++#ifdef __clang__
+++#pragma clang diagnostic pop
+++#endif
+++
+++#endif // CATCH_TEST_SPEC_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_OPTIONAL_HPP_INCLUDED
+++#define CATCH_OPTIONAL_HPP_INCLUDED
+++
+++
+++#include <cassert>
+++
+++namespace Catch {
+++
+++ // An optional type
+++ template<typename T>
+++ class Optional {
+++ public:
+++ Optional(): nullableValue( nullptr ) {}
+++ ~Optional() { reset(); }
+++
+++ Optional( T const& _value ):
+++ nullableValue( new ( storage ) T( _value ) ) {}
+++ Optional( T&& _value ):
+++ nullableValue( new ( storage ) T( CATCH_MOVE( _value ) ) ) {}
+++
+++ Optional& operator=( T const& _value ) {
+++ reset();
+++ nullableValue = new ( storage ) T( _value );
+++ return *this;
+++ }
+++ Optional& operator=( T&& _value ) {
+++ reset();
+++ nullableValue = new ( storage ) T( CATCH_MOVE( _value ) );
+++ return *this;
+++ }
+++
+++ Optional( Optional const& _other ):
+++ nullableValue( _other ? new ( storage ) T( *_other ) : nullptr ) {}
+++ Optional( Optional&& _other ):
+++ nullableValue( _other ? new ( storage ) T( CATCH_MOVE( *_other ) )
+++ : nullptr ) {}
+++
+++ Optional& operator=( Optional const& _other ) {
+++ if ( &_other != this ) {
+++ reset();
+++ if ( _other ) { nullableValue = new ( storage ) T( *_other ); }
+++ }
+++ return *this;
+++ }
+++ Optional& operator=( Optional&& _other ) {
+++ if ( &_other != this ) {
+++ reset();
+++ if ( _other ) {
+++ nullableValue = new ( storage ) T( CATCH_MOVE( *_other ) );
+++ }
+++ }
+++ return *this;
+++ }
+++
+++ void reset() {
+++ if ( nullableValue ) { nullableValue->~T(); }
+++ nullableValue = nullptr;
+++ }
+++
+++ T& operator*() {
+++ assert(nullableValue);
+++ return *nullableValue;
+++ }
+++ T const& operator*() const {
+++ assert(nullableValue);
+++ return *nullableValue;
+++ }
+++ T* operator->() {
+++ assert(nullableValue);
+++ return nullableValue;
+++ }
+++ const T* operator->() const {
+++ assert(nullableValue);
+++ return nullableValue;
+++ }
+++
+++ T valueOr( T const& defaultValue ) const {
+++ return nullableValue ? *nullableValue : defaultValue;
+++ }
+++
+++ bool some() const { return nullableValue != nullptr; }
+++ bool none() const { return nullableValue == nullptr; }
+++
+++ bool operator !() const { return nullableValue == nullptr; }
+++ explicit operator bool() const {
+++ return some();
+++ }
+++
+++ friend bool operator==(Optional const& a, Optional const& b) {
+++ if (a.none() && b.none()) {
+++ return true;
+++ } else if (a.some() && b.some()) {
+++ return *a == *b;
+++ } else {
+++ return false;
+++ }
+++ }
+++ friend bool operator!=(Optional const& a, Optional const& b) {
+++ return !( a == b );
+++ }
+++
+++ private:
+++ T* nullableValue;
+++ alignas(alignof(T)) char storage[sizeof(T)];
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_OPTIONAL_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
+++#define CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
+++
+++#include <cstdint>
+++
+++namespace Catch {
+++
+++ enum class GenerateFrom {
+++ Time,
+++ RandomDevice,
+++ //! Currently equivalent to RandomDevice, but can change at any point
+++ Default
+++ };
+++
+++ std::uint32_t generateRandomSeed(GenerateFrom from);
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_RANDOM_SEED_GENERATION_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
+++#define CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
+++
+++
+++#include <map>
+++#include <string>
+++#include <vector>
+++
+++namespace Catch {
+++
+++ enum class ColourMode : std::uint8_t;
+++
+++ namespace Detail {
+++ //! Splits the reporter spec into reporter name and kv-pair options
+++ std::vector<std::string> splitReporterSpec( StringRef reporterSpec );
+++
+++ Optional<ColourMode> stringToColourMode( StringRef colourMode );
+++ }
+++
+++ /**
+++ * Structured reporter spec that a reporter can be created from
+++ *
+++ * Parsing has been validated, but semantics have not. This means e.g.
+++ * that the colour mode is known to Catch2, but it might not be
+++ * compiled into the binary, and the output filename might not be
+++ * openable.
+++ */
+++ class ReporterSpec {
+++ std::string m_name;
+++ Optional<std::string> m_outputFileName;
+++ Optional<ColourMode> m_colourMode;
+++ std::map<std::string, std::string> m_customOptions;
+++
+++ friend bool operator==( ReporterSpec const& lhs,
+++ ReporterSpec const& rhs );
+++ friend bool operator!=( ReporterSpec const& lhs,
+++ ReporterSpec const& rhs ) {
+++ return !( lhs == rhs );
+++ }
+++
+++ public:
+++ ReporterSpec(
+++ std::string name,
+++ Optional<std::string> outputFileName,
+++ Optional<ColourMode> colourMode,
+++ std::map<std::string, std::string> customOptions );
+++
+++ std::string const& name() const { return m_name; }
+++
+++ Optional<std::string> const& outputFile() const {
+++ return m_outputFileName;
+++ }
+++
+++ Optional<ColourMode> const& colourMode() const { return m_colourMode; }
+++
+++ std::map<std::string, std::string> const& customOptions() const {
+++ return m_customOptions;
+++ }
+++ };
+++
+++ /**
+++ * Parses provided reporter spec string into
+++ *
+++ * Returns empty optional on errors, e.g.
+++ * * field that is not first and not a key+value pair
+++ * * duplicated keys in kv pair
+++ * * unknown catch reporter option
+++ * * empty key/value in an custom kv pair
+++ * * ...
+++ */
+++ Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec );
+++
+++}
+++
+++#endif // CATCH_REPORTER_SPEC_PARSER_HPP_INCLUDED
+++
+++#include <chrono>
+++#include <map>
+++#include <string>
+++#include <vector>
+++
+++namespace Catch {
+++
+++ class IStream;
+++
+++ /**
+++ * `ReporterSpec` but with the defaults filled in.
+++ *
+++ * Like `ReporterSpec`, the semantics are unchecked.
+++ */
+++ struct ProcessedReporterSpec {
+++ std::string name;
+++ std::string outputFilename;
+++ ColourMode colourMode;
+++ std::map<std::string, std::string> customOptions;
+++ friend bool operator==( ProcessedReporterSpec const& lhs,
+++ ProcessedReporterSpec const& rhs );
+++ friend bool operator!=( ProcessedReporterSpec const& lhs,
+++ ProcessedReporterSpec const& rhs ) {
+++ return !( lhs == rhs );
+++ }
+++ };
+++
+++ struct ConfigData {
+++
+++ bool listTests = false;
+++ bool listTags = false;
+++ bool listReporters = false;
+++ bool listListeners = false;
+++
+++ bool showSuccessfulTests = false;
+++ bool shouldDebugBreak = false;
+++ bool noThrow = false;
+++ bool showHelp = false;
+++ bool showInvisibles = false;
+++ bool filenamesAsTags = false;
+++ bool libIdentify = false;
+++ bool allowZeroTests = false;
+++
+++ int abortAfter = -1;
+++ uint32_t rngSeed = generateRandomSeed(GenerateFrom::Default);
+++
+++ unsigned int shardCount = 1;
+++ unsigned int shardIndex = 0;
+++
+++ bool skipBenchmarks = false;
+++ bool benchmarkNoAnalysis = false;
+++ unsigned int benchmarkSamples = 100;
+++ double benchmarkConfidenceInterval = 0.95;
+++ unsigned int benchmarkResamples = 100'000;
+++ std::chrono::milliseconds::rep benchmarkWarmupTime = 100;
+++
+++ Verbosity verbosity = Verbosity::Normal;
+++ WarnAbout::What warnings = WarnAbout::Nothing;
+++ ShowDurations showDurations = ShowDurations::DefaultForReporter;
+++ double minDuration = -1;
+++ TestRunOrder runOrder = TestRunOrder::Declared;
+++ ColourMode defaultColourMode = ColourMode::PlatformDefault;
+++ WaitForKeypress::When waitForKeypress = WaitForKeypress::Never;
+++
+++ std::string defaultOutputFilename;
+++ std::string name;
+++ std::string processName;
+++ std::vector<ReporterSpec> reporterSpecifications;
+++
+++ std::vector<std::string> testsOrTags;
+++ std::vector<std::string> sectionsToRun;
+++ };
+++
+++
+++ class Config : public IConfig {
+++ public:
+++
+++ Config() = default;
+++ Config( ConfigData const& data );
+++ ~Config() override; // = default in the cpp file
+++
+++ bool listTests() const;
+++ bool listTags() const;
+++ bool listReporters() const;
+++ bool listListeners() const;
+++
+++ std::vector<ReporterSpec> const& getReporterSpecs() const;
+++ std::vector<ProcessedReporterSpec> const&
+++ getProcessedReporterSpecs() const;
+++
+++ std::vector<std::string> const& getTestsOrTags() const override;
+++ std::vector<std::string> const& getSectionsToRun() const override;
+++
+++ TestSpec const& testSpec() const override;
+++ bool hasTestFilters() const override;
+++
+++ bool showHelp() const;
+++
+++ // IConfig interface
+++ bool allowThrows() const override;
+++ StringRef name() const override;
+++ bool includeSuccessfulResults() const override;
+++ bool warnAboutMissingAssertions() const override;
+++ bool warnAboutUnmatchedTestSpecs() const override;
+++ bool zeroTestsCountAsSuccess() const override;
+++ ShowDurations showDurations() const override;
+++ double minDuration() const override;
+++ TestRunOrder runOrder() const override;
+++ uint32_t rngSeed() const override;
+++ unsigned int shardCount() const override;
+++ unsigned int shardIndex() const override;
+++ ColourMode defaultColourMode() const override;
+++ bool shouldDebugBreak() const override;
+++ int abortAfter() const override;
+++ bool showInvisibles() const override;
+++ Verbosity verbosity() const override;
+++ bool skipBenchmarks() const override;
+++ bool benchmarkNoAnalysis() const override;
+++ unsigned int benchmarkSamples() const override;
+++ double benchmarkConfidenceInterval() const override;
+++ unsigned int benchmarkResamples() const override;
+++ std::chrono::milliseconds benchmarkWarmupTime() const override;
+++
+++ private:
+++ // Reads Bazel env vars and applies them to the config
+++ void readBazelEnvVars();
+++
+++ ConfigData m_data;
+++ std::vector<ProcessedReporterSpec> m_processedReporterSpecs;
+++ TestSpec m_testSpec;
+++ bool m_hasTestFilters = false;
+++ };
+++} // end namespace Catch
+++
+++#endif // CATCH_CONFIG_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_GET_RANDOM_SEED_HPP_INCLUDED
+++#define CATCH_GET_RANDOM_SEED_HPP_INCLUDED
+++
+++#include <cstdint>
+++
+++namespace Catch {
+++ //! Returns Catch2's current RNG seed.
+++ std::uint32_t getSeed();
+++}
+++
+++#endif // CATCH_GET_RANDOM_SEED_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_MESSAGE_HPP_INCLUDED
+++#define CATCH_MESSAGE_HPP_INCLUDED
+++
+++
+++
+++
+++/** \file
+++ * Wrapper for the CATCH_CONFIG_PREFIX_MESSAGES configuration option
+++ *
+++ * CATCH_CONFIG_PREFIX_ALL can be used to avoid clashes with other macros
+++ * by prepending CATCH_. This may not be desirable if the only clashes are with
+++ * logger macros such as INFO and WARN. In this cases
+++ * CATCH_CONFIG_PREFIX_MESSAGES can be used to only prefix a small subset
+++ * of relevant macros.
+++ *
+++ */
+++
+++#ifndef CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
+++#define CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
+++
+++
+++#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_PREFIX_MESSAGES)
+++ #define CATCH_CONFIG_PREFIX_MESSAGES
+++#endif
+++
+++#endif // CATCH_CONFIG_PREFIX_MESSAGES_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_STREAM_END_STOP_HPP_INCLUDED
+++#define CATCH_STREAM_END_STOP_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++
+++ // Use this in variadic streaming macros to allow
+++ // << +StreamEndStop
+++ // as well as
+++ // << stuff +StreamEndStop
+++ struct StreamEndStop {
+++ constexpr StringRef operator+() const { return StringRef(); }
+++
+++ template <typename T>
+++ constexpr friend T const& operator+( T const& value, StreamEndStop ) {
+++ return value;
+++ }
+++ };
+++
+++} // namespace Catch
+++
+++#endif // CATCH_STREAM_END_STOP_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_MESSAGE_INFO_HPP_INCLUDED
+++#define CATCH_MESSAGE_INFO_HPP_INCLUDED
+++
+++
+++#include <string>
+++
+++namespace Catch {
+++
+++ struct MessageInfo {
+++ MessageInfo( StringRef _macroName,
+++ SourceLineInfo const& _lineInfo,
+++ ResultWas::OfType _type );
+++
+++ StringRef macroName;
+++ std::string message;
+++ SourceLineInfo lineInfo;
+++ ResultWas::OfType type;
+++ unsigned int sequence;
+++
+++ bool operator == (MessageInfo const& other) const {
+++ return sequence == other.sequence;
+++ }
+++ bool operator < (MessageInfo const& other) const {
+++ return sequence < other.sequence;
+++ }
+++ private:
+++ static unsigned int globalCount;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_MESSAGE_INFO_HPP_INCLUDED
+++
+++#include <string>
+++#include <vector>
+++
+++namespace Catch {
+++
+++ struct SourceLineInfo;
+++ class IResultCapture;
+++
+++ struct MessageStream {
+++
+++ template<typename T>
+++ MessageStream& operator << ( T const& value ) {
+++ m_stream << value;
+++ return *this;
+++ }
+++
+++ ReusableStringStream m_stream;
+++ };
+++
+++ struct MessageBuilder : MessageStream {
+++ MessageBuilder( StringRef macroName,
+++ SourceLineInfo const& lineInfo,
+++ ResultWas::OfType type ):
+++ m_info(macroName, lineInfo, type) {}
+++
+++ template<typename T>
+++ MessageBuilder&& operator << ( T const& value ) && {
+++ m_stream << value;
+++ return CATCH_MOVE(*this);
+++ }
+++
+++ MessageInfo m_info;
+++ };
+++
+++ class ScopedMessage {
+++ public:
+++ explicit ScopedMessage( MessageBuilder&& builder );
+++ ScopedMessage( ScopedMessage& duplicate ) = delete;
+++ ScopedMessage( ScopedMessage&& old ) noexcept;
+++ ~ScopedMessage();
+++
+++ MessageInfo m_info;
+++ bool m_moved = false;
+++ };
+++
+++ class Capturer {
+++ std::vector<MessageInfo> m_messages;
+++ IResultCapture& m_resultCapture;
+++ size_t m_captured = 0;
+++ public:
+++ Capturer( StringRef macroName, SourceLineInfo const& lineInfo, ResultWas::OfType resultType, StringRef names );
+++
+++ Capturer(Capturer const&) = delete;
+++ Capturer& operator=(Capturer const&) = delete;
+++
+++ ~Capturer();
+++
+++ void captureValue( size_t index, std::string const& value );
+++
+++ template<typename T>
+++ void captureValues( size_t index, T const& value ) {
+++ captureValue( index, Catch::Detail::stringify( value ) );
+++ }
+++
+++ template<typename T, typename... Ts>
+++ void captureValues( size_t index, T const& value, Ts const&... values ) {
+++ captureValue( index, Catch::Detail::stringify(value) );
+++ captureValues( index+1, values... );
+++ }
+++ };
+++
+++} // end namespace Catch
+++
+++///////////////////////////////////////////////////////////////////////////////
+++#define INTERNAL_CATCH_MSG( macroName, messageType, resultDisposition, ... ) \
+++ do { \
+++ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::StringRef(), resultDisposition ); \
+++ catchAssertionHandler.handleMessage( messageType, ( Catch::MessageStream() << __VA_ARGS__ + ::Catch::StreamEndStop() ).m_stream.str() ); \
+++ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+++ } while( false )
+++
+++///////////////////////////////////////////////////////////////////////////////
+++#define INTERNAL_CATCH_CAPTURE( varName, macroName, ... ) \
+++ Catch::Capturer varName( macroName##_catch_sr, \
+++ CATCH_INTERNAL_LINEINFO, \
+++ Catch::ResultWas::Info, \
+++ #__VA_ARGS__##_catch_sr ); \
+++ varName.captureValues( 0, __VA_ARGS__ )
+++
+++///////////////////////////////////////////////////////////////////////////////
+++#define INTERNAL_CATCH_INFO( macroName, log ) \
+++ const Catch::ScopedMessage INTERNAL_CATCH_UNIQUE_NAME( scopedMessage )( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+++
+++///////////////////////////////////////////////////////////////////////////////
+++#define INTERNAL_CATCH_UNSCOPED_INFO( macroName, log ) \
+++ Catch::getResultCapture().emplaceUnscopedMessage( Catch::MessageBuilder( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, Catch::ResultWas::Info ) << log )
+++
+++
+++#if defined(CATCH_CONFIG_PREFIX_MESSAGES) && !defined(CATCH_CONFIG_DISABLE)
+++
+++ #define CATCH_INFO( msg ) INTERNAL_CATCH_INFO( "CATCH_INFO", msg )
+++ #define CATCH_UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "CATCH_UNSCOPED_INFO", msg )
+++ #define CATCH_WARN( msg ) INTERNAL_CATCH_MSG( "CATCH_WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+++ #define CATCH_CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CATCH_CAPTURE", __VA_ARGS__ )
+++
+++#elif defined(CATCH_CONFIG_PREFIX_MESSAGES) && defined(CATCH_CONFIG_DISABLE)
+++
+++ #define CATCH_INFO( msg ) (void)(0)
+++ #define CATCH_UNSCOPED_INFO( msg ) (void)(0)
+++ #define CATCH_WARN( msg ) (void)(0)
+++ #define CATCH_CAPTURE( ... ) (void)(0)
+++
+++#elif !defined(CATCH_CONFIG_PREFIX_MESSAGES) && !defined(CATCH_CONFIG_DISABLE)
+++
+++ #define INFO( msg ) INTERNAL_CATCH_INFO( "INFO", msg )
+++ #define UNSCOPED_INFO( msg ) INTERNAL_CATCH_UNSCOPED_INFO( "UNSCOPED_INFO", msg )
+++ #define WARN( msg ) INTERNAL_CATCH_MSG( "WARN", Catch::ResultWas::Warning, Catch::ResultDisposition::ContinueOnFailure, msg )
+++ #define CAPTURE( ... ) INTERNAL_CATCH_CAPTURE( INTERNAL_CATCH_UNIQUE_NAME(capturer), "CAPTURE", __VA_ARGS__ )
+++
+++#elif !defined(CATCH_CONFIG_PREFIX_MESSAGES) && defined(CATCH_CONFIG_DISABLE)
+++
+++ #define INFO( msg ) (void)(0)
+++ #define UNSCOPED_INFO( msg ) (void)(0)
+++ #define WARN( msg ) (void)(0)
+++ #define CAPTURE( ... ) (void)(0)
+++
+++#endif // end of user facing macro declarations
+++
+++
+++
+++
+++#endif // CATCH_MESSAGE_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_SECTION_INFO_HPP_INCLUDED
+++#define CATCH_SECTION_INFO_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_TOTALS_HPP_INCLUDED
+++#define CATCH_TOTALS_HPP_INCLUDED
+++
+++#include <cstdint>
+++
+++namespace Catch {
+++
+++ struct Counts {
+++ Counts operator - ( Counts const& other ) const;
+++ Counts& operator += ( Counts const& other );
+++
+++ std::uint64_t total() const;
+++ bool allPassed() const;
+++ bool allOk() const;
+++
+++ std::uint64_t passed = 0;
+++ std::uint64_t failed = 0;
+++ std::uint64_t failedButOk = 0;
+++ std::uint64_t skipped = 0;
+++ };
+++
+++ struct Totals {
+++
+++ Totals operator - ( Totals const& other ) const;
+++ Totals& operator += ( Totals const& other );
+++
+++ Totals delta( Totals const& prevTotals ) const;
+++
+++ Counts assertions;
+++ Counts testCases;
+++ };
+++}
+++
+++#endif // CATCH_TOTALS_HPP_INCLUDED
+++
+++#include <string>
+++
+++namespace Catch {
+++
+++ struct SectionInfo {
+++ // The last argument is ignored, so that people can write
+++ // SECTION("ShortName", "Proper description that is long") and
+++ // still use the `-c` flag comfortably.
+++ SectionInfo( SourceLineInfo const& _lineInfo, std::string _name,
+++ const char* const = nullptr ):
+++ name(CATCH_MOVE(_name)),
+++ lineInfo(_lineInfo)
+++ {}
+++
+++ std::string name;
+++ SourceLineInfo lineInfo;
+++ };
+++
+++ struct SectionEndInfo {
+++ SectionInfo sectionInfo;
+++ Counts prevAssertions;
+++ double durationInSeconds;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_SECTION_INFO_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_SESSION_HPP_INCLUDED
+++#define CATCH_SESSION_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_COMMANDLINE_HPP_INCLUDED
+++#define CATCH_COMMANDLINE_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_CLARA_HPP_INCLUDED
+++#define CATCH_CLARA_HPP_INCLUDED
+++
+++#if defined( __clang__ )
+++# pragma clang diagnostic push
+++# pragma clang diagnostic ignored "-Wweak-vtables"
+++# pragma clang diagnostic ignored "-Wshadow"
+++# pragma clang diagnostic ignored "-Wdeprecated"
+++#endif
+++
+++#if defined( __GNUC__ )
+++# pragma GCC diagnostic push
+++# pragma GCC diagnostic ignored "-Wsign-conversion"
+++#endif
+++
+++#ifndef CLARA_CONFIG_OPTIONAL_TYPE
+++# ifdef __has_include
+++# if __has_include( <optional>) && __cplusplus >= 201703L
+++# include <optional>
+++# define CLARA_CONFIG_OPTIONAL_TYPE std::optional
+++# endif
+++# endif
+++#endif
+++
+++
+++#include <cassert>
+++#include <memory>
+++#include <ostream>
+++#include <sstream>
+++#include <string>
+++#include <type_traits>
+++#include <vector>
+++
+++namespace Catch {
+++ namespace Clara {
+++
+++ class Args;
+++ class Parser;
+++
+++ // enum of result types from a parse
+++ enum class ParseResultType {
+++ Matched,
+++ NoMatch,
+++ ShortCircuitAll,
+++ ShortCircuitSame
+++ };
+++
+++ struct accept_many_t {};
+++ constexpr accept_many_t accept_many {};
+++
+++ namespace Detail {
+++ struct fake_arg {
+++ template <typename T>
+++ operator T();
+++ };
+++
+++ template <typename F, typename = void>
+++ struct is_unary_function : std::false_type {};
+++
+++ template <typename F>
+++ struct is_unary_function<
+++ F,
+++ Catch::Detail::void_t<decltype(
+++ std::declval<F>()( fake_arg() ) )
+++ >
+++ > : std::true_type {};
+++
+++ // Traits for extracting arg and return type of lambdas (for single
+++ // argument lambdas)
+++ template <typename L>
+++ struct UnaryLambdaTraits
+++ : UnaryLambdaTraits<decltype( &L::operator() )> {};
+++
+++ template <typename ClassT, typename ReturnT, typename... Args>
+++ struct UnaryLambdaTraits<ReturnT ( ClassT::* )( Args... ) const> {
+++ static const bool isValid = false;
+++ };
+++
+++ template <typename ClassT, typename ReturnT, typename ArgT>
+++ struct UnaryLambdaTraits<ReturnT ( ClassT::* )( ArgT ) const> {
+++ static const bool isValid = true;
+++ using ArgType = std::remove_const_t<std::remove_reference_t<ArgT>>;
+++ using ReturnType = ReturnT;
+++ };
+++
+++ class TokenStream;
+++
+++ // Wraps a token coming from a token stream. These may not directly
+++ // correspond to strings as a single string may encode an option +
+++ // its argument if the : or = form is used
+++ enum class TokenType { Option, Argument };
+++ struct Token {
+++ TokenType type;
+++ StringRef token;
+++ };
+++
+++ // Abstracts iterators into args as a stream of tokens, with option
+++ // arguments uniformly handled
+++ class TokenStream {
+++ using Iterator = std::vector<StringRef>::const_iterator;
+++ Iterator it;
+++ Iterator itEnd;
+++ std::vector<Token> m_tokenBuffer;
+++ void loadBuffer();
+++
+++ public:
+++ explicit TokenStream( Args const& args );
+++ TokenStream( Iterator it, Iterator itEnd );
+++
+++ explicit operator bool() const {
+++ return !m_tokenBuffer.empty() || it != itEnd;
+++ }
+++
+++ size_t count() const {
+++ return m_tokenBuffer.size() + ( itEnd - it );
+++ }
+++
+++ Token operator*() const {
+++ assert( !m_tokenBuffer.empty() );
+++ return m_tokenBuffer.front();
+++ }
+++
+++ Token const* operator->() const {
+++ assert( !m_tokenBuffer.empty() );
+++ return &m_tokenBuffer.front();
+++ }
+++
+++ TokenStream& operator++();
+++ };
+++
+++ //! Denotes type of a parsing result
+++ enum class ResultType {
+++ Ok, ///< No errors
+++ LogicError, ///< Error in user-specified arguments for
+++ ///< construction
+++ RuntimeError ///< Error in parsing inputs
+++ };
+++
+++ class ResultBase {
+++ protected:
+++ ResultBase( ResultType type ): m_type( type ) {}
+++ virtual ~ResultBase(); // = default;
+++
+++
+++ ResultBase(ResultBase const&) = default;
+++ ResultBase& operator=(ResultBase const&) = default;
+++ ResultBase(ResultBase&&) = default;
+++ ResultBase& operator=(ResultBase&&) = default;
+++
+++ virtual void enforceOk() const = 0;
+++
+++ ResultType m_type;
+++ };
+++
+++ template <typename T>
+++ class ResultValueBase : public ResultBase {
+++ public:
+++ T const& value() const& {
+++ enforceOk();
+++ return m_value;
+++ }
+++ T&& value() && {
+++ enforceOk();
+++ return CATCH_MOVE( m_value );
+++ }
+++
+++ protected:
+++ ResultValueBase( ResultType type ): ResultBase( type ) {}
+++
+++ ResultValueBase( ResultValueBase const& other ):
+++ ResultBase( other ) {
+++ if ( m_type == ResultType::Ok )
+++ new ( &m_value ) T( other.m_value );
+++ }
+++ ResultValueBase( ResultValueBase&& other ):
+++ ResultBase( other ) {
+++ if ( m_type == ResultType::Ok )
+++ new ( &m_value ) T( CATCH_MOVE(other.m_value) );
+++ }
+++
+++
+++ ResultValueBase( ResultType, T const& value ):
+++ ResultBase( ResultType::Ok ) {
+++ new ( &m_value ) T( value );
+++ }
+++ ResultValueBase( ResultType, T&& value ):
+++ ResultBase( ResultType::Ok ) {
+++ new ( &m_value ) T( CATCH_MOVE(value) );
+++ }
+++
+++ ResultValueBase& operator=( ResultValueBase const& other ) {
+++ if ( m_type == ResultType::Ok )
+++ m_value.~T();
+++ ResultBase::operator=( other );
+++ if ( m_type == ResultType::Ok )
+++ new ( &m_value ) T( other.m_value );
+++ return *this;
+++ }
+++ ResultValueBase& operator=( ResultValueBase&& other ) {
+++ if ( m_type == ResultType::Ok ) m_value.~T();
+++ ResultBase::operator=( other );
+++ if ( m_type == ResultType::Ok )
+++ new ( &m_value ) T( CATCH_MOVE(other.m_value) );
+++ return *this;
+++ }
+++
+++
+++ ~ResultValueBase() override {
+++ if ( m_type == ResultType::Ok )
+++ m_value.~T();
+++ }
+++
+++ union {
+++ T m_value;
+++ };
+++ };
+++
+++ template <> class ResultValueBase<void> : public ResultBase {
+++ protected:
+++ using ResultBase::ResultBase;
+++ };
+++
+++ template <typename T = void>
+++ class BasicResult : public ResultValueBase<T> {
+++ public:
+++ template <typename U>
+++ explicit BasicResult( BasicResult<U> const& other ):
+++ ResultValueBase<T>( other.type() ),
+++ m_errorMessage( other.errorMessage() ) {
+++ assert( type() != ResultType::Ok );
+++ }
+++
+++ template <typename U>
+++ static auto ok( U&& value ) -> BasicResult {
+++ return { ResultType::Ok, CATCH_FORWARD(value) };
+++ }
+++ static auto ok() -> BasicResult { return { ResultType::Ok }; }
+++ static auto logicError( std::string&& message )
+++ -> BasicResult {
+++ return { ResultType::LogicError, CATCH_MOVE(message) };
+++ }
+++ static auto runtimeError( std::string&& message )
+++ -> BasicResult {
+++ return { ResultType::RuntimeError, CATCH_MOVE(message) };
+++ }
+++
+++ explicit operator bool() const {
+++ return m_type == ResultType::Ok;
+++ }
+++ auto type() const -> ResultType { return m_type; }
+++ auto errorMessage() const -> std::string const& {
+++ return m_errorMessage;
+++ }
+++
+++ protected:
+++ void enforceOk() const override {
+++
+++ // Errors shouldn't reach this point, but if they do
+++ // the actual error message will be in m_errorMessage
+++ assert( m_type != ResultType::LogicError );
+++ assert( m_type != ResultType::RuntimeError );
+++ if ( m_type != ResultType::Ok )
+++ std::abort();
+++ }
+++
+++ std::string
+++ m_errorMessage; // Only populated if resultType is an error
+++
+++ BasicResult( ResultType type,
+++ std::string&& message ):
+++ ResultValueBase<T>( type ), m_errorMessage( CATCH_MOVE(message) ) {
+++ assert( m_type != ResultType::Ok );
+++ }
+++
+++ using ResultValueBase<T>::ResultValueBase;
+++ using ResultBase::m_type;
+++ };
+++
+++ class ParseState {
+++ public:
+++ ParseState( ParseResultType type,
+++ TokenStream remainingTokens );
+++
+++ ParseResultType type() const { return m_type; }
+++ TokenStream const& remainingTokens() const& {
+++ return m_remainingTokens;
+++ }
+++ TokenStream&& remainingTokens() && {
+++ return CATCH_MOVE( m_remainingTokens );
+++ }
+++
+++ private:
+++ ParseResultType m_type;
+++ TokenStream m_remainingTokens;
+++ };
+++
+++ using Result = BasicResult<void>;
+++ using ParserResult = BasicResult<ParseResultType>;
+++ using InternalParseResult = BasicResult<ParseState>;
+++
+++ struct HelpColumns {
+++ std::string left;
+++ StringRef descriptions;
+++ };
+++
+++ template <typename T>
+++ ParserResult convertInto( std::string const& source, T& target ) {
+++ std::stringstream ss( source );
+++ ss >> target;
+++ if ( ss.fail() ) {
+++ return ParserResult::runtimeError(
+++ "Unable to convert '" + source +
+++ "' to destination type" );
+++ } else {
+++ return ParserResult::ok( ParseResultType::Matched );
+++ }
+++ }
+++ ParserResult convertInto( std::string const& source,
+++ std::string& target );
+++ ParserResult convertInto( std::string const& source, bool& target );
+++
+++#ifdef CLARA_CONFIG_OPTIONAL_TYPE
+++ template <typename T>
+++ auto convertInto( std::string const& source,
+++ CLARA_CONFIG_OPTIONAL_TYPE<T>& target )
+++ -> ParserResult {
+++ T temp;
+++ auto result = convertInto( source, temp );
+++ if ( result )
+++ target = CATCH_MOVE( temp );
+++ return result;
+++ }
+++#endif // CLARA_CONFIG_OPTIONAL_TYPE
+++
+++ struct BoundRef : Catch::Detail::NonCopyable {
+++ virtual ~BoundRef() = default;
+++ virtual bool isContainer() const;
+++ virtual bool isFlag() const;
+++ };
+++ struct BoundValueRefBase : BoundRef {
+++ virtual auto setValue( std::string const& arg )
+++ -> ParserResult = 0;
+++ };
+++ struct BoundFlagRefBase : BoundRef {
+++ virtual auto setFlag( bool flag ) -> ParserResult = 0;
+++ bool isFlag() const override;
+++ };
+++
+++ template <typename T> struct BoundValueRef : BoundValueRefBase {
+++ T& m_ref;
+++
+++ explicit BoundValueRef( T& ref ): m_ref( ref ) {}
+++
+++ ParserResult setValue( std::string const& arg ) override {
+++ return convertInto( arg, m_ref );
+++ }
+++ };
+++
+++ template <typename T>
+++ struct BoundValueRef<std::vector<T>> : BoundValueRefBase {
+++ std::vector<T>& m_ref;
+++
+++ explicit BoundValueRef( std::vector<T>& ref ): m_ref( ref ) {}
+++
+++ auto isContainer() const -> bool override { return true; }
+++
+++ auto setValue( std::string const& arg )
+++ -> ParserResult override {
+++ T temp;
+++ auto result = convertInto( arg, temp );
+++ if ( result )
+++ m_ref.push_back( temp );
+++ return result;
+++ }
+++ };
+++
+++ struct BoundFlagRef : BoundFlagRefBase {
+++ bool& m_ref;
+++
+++ explicit BoundFlagRef( bool& ref ): m_ref( ref ) {}
+++
+++ ParserResult setFlag( bool flag ) override;
+++ };
+++
+++ template <typename ReturnType> struct LambdaInvoker {
+++ static_assert(
+++ std::is_same<ReturnType, ParserResult>::value,
+++ "Lambda must return void or clara::ParserResult" );
+++
+++ template <typename L, typename ArgType>
+++ static auto invoke( L const& lambda, ArgType const& arg )
+++ -> ParserResult {
+++ return lambda( arg );
+++ }
+++ };
+++
+++ template <> struct LambdaInvoker<void> {
+++ template <typename L, typename ArgType>
+++ static auto invoke( L const& lambda, ArgType const& arg )
+++ -> ParserResult {
+++ lambda( arg );
+++ return ParserResult::ok( ParseResultType::Matched );
+++ }
+++ };
+++
+++ template <typename ArgType, typename L>
+++ auto invokeLambda( L const& lambda, std::string const& arg )
+++ -> ParserResult {
+++ ArgType temp{};
+++ auto result = convertInto( arg, temp );
+++ return !result ? result
+++ : LambdaInvoker<typename UnaryLambdaTraits<
+++ L>::ReturnType>::invoke( lambda, temp );
+++ }
+++
+++ template <typename L> struct BoundLambda : BoundValueRefBase {
+++ L m_lambda;
+++
+++ static_assert(
+++ UnaryLambdaTraits<L>::isValid,
+++ "Supplied lambda must take exactly one argument" );
+++ explicit BoundLambda( L const& lambda ): m_lambda( lambda ) {}
+++
+++ auto setValue( std::string const& arg )
+++ -> ParserResult override {
+++ return invokeLambda<typename UnaryLambdaTraits<L>::ArgType>(
+++ m_lambda, arg );
+++ }
+++ };
+++
+++ template <typename L> struct BoundManyLambda : BoundLambda<L> {
+++ explicit BoundManyLambda( L const& lambda ): BoundLambda<L>( lambda ) {}
+++ bool isContainer() const override { return true; }
+++ };
+++
+++ template <typename L> struct BoundFlagLambda : BoundFlagRefBase {
+++ L m_lambda;
+++
+++ static_assert(
+++ UnaryLambdaTraits<L>::isValid,
+++ "Supplied lambda must take exactly one argument" );
+++ static_assert(
+++ std::is_same<typename UnaryLambdaTraits<L>::ArgType,
+++ bool>::value,
+++ "flags must be boolean" );
+++
+++ explicit BoundFlagLambda( L const& lambda ):
+++ m_lambda( lambda ) {}
+++
+++ auto setFlag( bool flag ) -> ParserResult override {
+++ return LambdaInvoker<typename UnaryLambdaTraits<
+++ L>::ReturnType>::invoke( m_lambda, flag );
+++ }
+++ };
+++
+++ enum class Optionality { Optional, Required };
+++
+++ class ParserBase {
+++ public:
+++ virtual ~ParserBase() = default;
+++ virtual auto validate() const -> Result { return Result::ok(); }
+++ virtual auto parse( std::string const& exeName,
+++ TokenStream tokens ) const
+++ -> InternalParseResult = 0;
+++ virtual size_t cardinality() const;
+++
+++ InternalParseResult parse( Args const& args ) const;
+++ };
+++
+++ template <typename DerivedT>
+++ class ComposableParserImpl : public ParserBase {
+++ public:
+++ template <typename T>
+++ auto operator|( T const& other ) const -> Parser;
+++ };
+++
+++ // Common code and state for Args and Opts
+++ template <typename DerivedT>
+++ class ParserRefImpl : public ComposableParserImpl<DerivedT> {
+++ protected:
+++ Optionality m_optionality = Optionality::Optional;
+++ std::shared_ptr<BoundRef> m_ref;
+++ StringRef m_hint;
+++ StringRef m_description;
+++
+++ explicit ParserRefImpl( std::shared_ptr<BoundRef> const& ref ):
+++ m_ref( ref ) {}
+++
+++ public:
+++ template <typename LambdaT>
+++ ParserRefImpl( accept_many_t,
+++ LambdaT const& ref,
+++ StringRef hint ):
+++ m_ref( std::make_shared<BoundManyLambda<LambdaT>>( ref ) ),
+++ m_hint( hint ) {}
+++
+++ template <typename T,
+++ typename = typename std::enable_if_t<
+++ !Detail::is_unary_function<T>::value>>
+++ ParserRefImpl( T& ref, StringRef hint ):
+++ m_ref( std::make_shared<BoundValueRef<T>>( ref ) ),
+++ m_hint( hint ) {}
+++
+++ template <typename LambdaT,
+++ typename = typename std::enable_if_t<
+++ Detail::is_unary_function<LambdaT>::value>>
+++ ParserRefImpl( LambdaT const& ref, StringRef hint ):
+++ m_ref( std::make_shared<BoundLambda<LambdaT>>( ref ) ),
+++ m_hint( hint ) {}
+++
+++ DerivedT& operator()( StringRef description ) & {
+++ m_description = description;
+++ return static_cast<DerivedT&>( *this );
+++ }
+++ DerivedT&& operator()( StringRef description ) && {
+++ m_description = description;
+++ return static_cast<DerivedT&&>( *this );
+++ }
+++
+++ auto optional() -> DerivedT& {
+++ m_optionality = Optionality::Optional;
+++ return static_cast<DerivedT&>( *this );
+++ }
+++
+++ auto required() -> DerivedT& {
+++ m_optionality = Optionality::Required;
+++ return static_cast<DerivedT&>( *this );
+++ }
+++
+++ auto isOptional() const -> bool {
+++ return m_optionality == Optionality::Optional;
+++ }
+++
+++ auto cardinality() const -> size_t override {
+++ if ( m_ref->isContainer() )
+++ return 0;
+++ else
+++ return 1;
+++ }
+++
+++ StringRef hint() const { return m_hint; }
+++ };
+++
+++ } // namespace detail
+++
+++
+++ // A parser for arguments
+++ class Arg : public Detail::ParserRefImpl<Arg> {
+++ public:
+++ using ParserRefImpl::ParserRefImpl;
+++ using ParserBase::parse;
+++
+++ Detail::InternalParseResult
+++ parse(std::string const&,
+++ Detail::TokenStream tokens) const override;
+++ };
+++
+++ // A parser for options
+++ class Opt : public Detail::ParserRefImpl<Opt> {
+++ protected:
+++ std::vector<StringRef> m_optNames;
+++
+++ public:
+++ template <typename LambdaT>
+++ explicit Opt(LambdaT const& ref) :
+++ ParserRefImpl(
+++ std::make_shared<Detail::BoundFlagLambda<LambdaT>>(ref)) {}
+++
+++ explicit Opt(bool& ref);
+++
+++ template <typename LambdaT,
+++ typename = typename std::enable_if_t<
+++ Detail::is_unary_function<LambdaT>::value>>
+++ Opt( LambdaT const& ref, StringRef hint ):
+++ ParserRefImpl( ref, hint ) {}
+++
+++ template <typename LambdaT>
+++ Opt( accept_many_t, LambdaT const& ref, StringRef hint ):
+++ ParserRefImpl( accept_many, ref, hint ) {}
+++
+++ template <typename T,
+++ typename = typename std::enable_if_t<
+++ !Detail::is_unary_function<T>::value>>
+++ Opt( T& ref, StringRef hint ):
+++ ParserRefImpl( ref, hint ) {}
+++
+++ Opt& operator[]( StringRef optName ) & {
+++ m_optNames.push_back(optName);
+++ return *this;
+++ }
+++ Opt&& operator[]( StringRef optName ) && {
+++ m_optNames.push_back( optName );
+++ return CATCH_MOVE(*this);
+++ }
+++
+++ Detail::HelpColumns getHelpColumns() const;
+++
+++ bool isMatch(StringRef optToken) const;
+++
+++ using ParserBase::parse;
+++
+++ Detail::InternalParseResult
+++ parse(std::string const&,
+++ Detail::TokenStream tokens) const override;
+++
+++ Detail::Result validate() const override;
+++ };
+++
+++ // Specifies the name of the executable
+++ class ExeName : public Detail::ComposableParserImpl<ExeName> {
+++ std::shared_ptr<std::string> m_name;
+++ std::shared_ptr<Detail::BoundValueRefBase> m_ref;
+++
+++ public:
+++ ExeName();
+++ explicit ExeName(std::string& ref);
+++
+++ template <typename LambdaT>
+++ explicit ExeName(LambdaT const& lambda) : ExeName() {
+++ m_ref = std::make_shared<Detail::BoundLambda<LambdaT>>(lambda);
+++ }
+++
+++ // The exe name is not parsed out of the normal tokens, but is
+++ // handled specially
+++ Detail::InternalParseResult
+++ parse(std::string const&,
+++ Detail::TokenStream tokens) const override;
+++
+++ std::string const& name() const { return *m_name; }
+++ Detail::ParserResult set(std::string const& newName);
+++ };
+++
+++
+++ // A Combined parser
+++ class Parser : Detail::ParserBase {
+++ mutable ExeName m_exeName;
+++ std::vector<Opt> m_options;
+++ std::vector<Arg> m_args;
+++
+++ public:
+++
+++ auto operator|=(ExeName const& exeName) -> Parser& {
+++ m_exeName = exeName;
+++ return *this;
+++ }
+++
+++ auto operator|=(Arg const& arg) -> Parser& {
+++ m_args.push_back(arg);
+++ return *this;
+++ }
+++
+++ friend Parser& operator|=( Parser& p, Opt const& opt ) {
+++ p.m_options.push_back( opt );
+++ return p;
+++ }
+++ friend Parser& operator|=( Parser& p, Opt&& opt ) {
+++ p.m_options.push_back( CATCH_MOVE(opt) );
+++ return p;
+++ }
+++
+++ Parser& operator|=(Parser const& other);
+++
+++ template <typename T>
+++ friend Parser operator|( Parser const& p, T&& rhs ) {
+++ Parser temp( p );
+++ temp |= rhs;
+++ return temp;
+++ }
+++
+++ template <typename T>
+++ friend Parser operator|( Parser&& p, T&& rhs ) {
+++ p |= CATCH_FORWARD(rhs);
+++ return CATCH_MOVE(p);
+++ }
+++
+++ std::vector<Detail::HelpColumns> getHelpColumns() const;
+++
+++ void writeToStream(std::ostream& os) const;
+++
+++ friend auto operator<<(std::ostream& os, Parser const& parser)
+++ -> std::ostream& {
+++ parser.writeToStream(os);
+++ return os;
+++ }
+++
+++ Detail::Result validate() const override;
+++
+++ using ParserBase::parse;
+++ Detail::InternalParseResult
+++ parse(std::string const& exeName,
+++ Detail::TokenStream tokens) const override;
+++ };
+++
+++ /**
+++ * Wrapper over argc + argv, assumes that the inputs outlive it
+++ */
+++ class Args {
+++ friend Detail::TokenStream;
+++ StringRef m_exeName;
+++ std::vector<StringRef> m_args;
+++
+++ public:
+++ Args(int argc, char const* const* argv);
+++ // Helper constructor for testing
+++ Args(std::initializer_list<StringRef> args);
+++
+++ StringRef exeName() const { return m_exeName; }
+++ };
+++
+++
+++ // Convenience wrapper for option parser that specifies the help option
+++ struct Help : Opt {
+++ Help(bool& showHelpFlag);
+++ };
+++
+++ // Result type for parser operation
+++ using Detail::ParserResult;
+++
+++ namespace Detail {
+++ template <typename DerivedT>
+++ template <typename T>
+++ Parser
+++ ComposableParserImpl<DerivedT>::operator|(T const& other) const {
+++ return Parser() | static_cast<DerivedT const&>(*this) | other;
+++ }
+++ }
+++
+++ } // namespace Clara
+++} // namespace Catch
+++
+++#if defined( __clang__ )
+++# pragma clang diagnostic pop
+++#endif
+++
+++#if defined( __GNUC__ )
+++# pragma GCC diagnostic pop
+++#endif
+++
+++#endif // CATCH_CLARA_HPP_INCLUDED
+++
+++namespace Catch {
+++
+++ struct ConfigData;
+++
+++ Clara::Parser makeCommandLineParser( ConfigData& config );
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_COMMANDLINE_HPP_INCLUDED
+++
+++namespace Catch {
+++
+++ class Session : Detail::NonCopyable {
+++ public:
+++
+++ Session();
+++ ~Session();
+++
+++ void showHelp() const;
+++ void libIdentify();
+++
+++ int applyCommandLine( int argc, char const * const * argv );
+++ #if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+++ int applyCommandLine( int argc, wchar_t const * const * argv );
+++ #endif
+++
+++ void useConfigData( ConfigData const& configData );
+++
+++ template<typename CharT>
+++ int run(int argc, CharT const * const argv[]) {
+++ if (m_startupExceptions)
+++ return 1;
+++ int returnCode = applyCommandLine(argc, argv);
+++ if (returnCode == 0)
+++ returnCode = run();
+++ return returnCode;
+++ }
+++
+++ int run();
+++
+++ Clara::Parser const& cli() const;
+++ void cli( Clara::Parser const& newParser );
+++ ConfigData& configData();
+++ Config& config();
+++ private:
+++ int runInternal();
+++
+++ Clara::Parser m_cli;
+++ ConfigData m_configData;
+++ Detail::unique_ptr<Config> m_config;
+++ bool m_startupExceptions = false;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_SESSION_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_TAG_ALIAS_HPP_INCLUDED
+++#define CATCH_TAG_ALIAS_HPP_INCLUDED
+++
+++
+++#include <string>
+++
+++namespace Catch {
+++
+++ struct TagAlias {
+++ TagAlias(std::string const& _tag, SourceLineInfo _lineInfo):
+++ tag(_tag),
+++ lineInfo(_lineInfo)
+++ {}
+++
+++ std::string tag;
+++ SourceLineInfo lineInfo;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_TAG_ALIAS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
+++#define CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++
+++ struct RegistrarForTagAliases {
+++ RegistrarForTagAliases( char const* alias, char const* tag, SourceLineInfo const& lineInfo );
+++ };
+++
+++} // end namespace Catch
+++
+++#define CATCH_REGISTER_TAG_ALIAS( alias, spec ) \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+++ namespace{ Catch::RegistrarForTagAliases INTERNAL_CATCH_UNIQUE_NAME( AutoRegisterTagAlias )( alias, spec, CATCH_INTERNAL_LINEINFO ); } \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+++
+++#endif // CATCH_TAG_ALIAS_AUTOREGISTRAR_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
+++#define CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
+++
+++// We need this suppression to leak, because it took until GCC 10
+++// for the front end to handle local suppression via _Pragma properly
+++// inside templates (so `TEMPLATE_TEST_CASE` and co).
+++// **THIS IS DIFFERENT FOR STANDARD TESTS, WHERE GCC 9 IS SUFFICIENT**
+++#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && __GNUC__ < 10
+++#pragma GCC diagnostic ignored "-Wparentheses"
+++#endif
+++
+++
+++
+++
+++#ifndef CATCH_TEST_MACROS_HPP_INCLUDED
+++#define CATCH_TEST_MACROS_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
+++#define CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_ASSERTION_HANDLER_HPP_INCLUDED
+++#define CATCH_ASSERTION_HANDLER_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_DECOMPOSER_HPP_INCLUDED
+++#define CATCH_DECOMPOSER_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_COMPARE_TRAITS_HPP_INCLUDED
+++#define CATCH_COMPARE_TRAITS_HPP_INCLUDED
+++
+++
+++#include <type_traits>
+++
+++namespace Catch {
+++ namespace Detail {
+++
+++#if defined( __GNUC__ ) && !defined( __clang__ )
+++# pragma GCC diagnostic push
+++ // GCC likes to complain about comparing bool with 0, in the decltype()
+++ // that defines the comparable traits below.
+++# pragma GCC diagnostic ignored "-Wbool-compare"
+++ // "ordered comparison of pointer with integer zero" same as above,
+++ // but it does not have a separate warning flag to suppress
+++# pragma GCC diagnostic ignored "-Wextra"
+++ // Did you know that comparing floats with `0` directly
+++ // is super-duper dangerous in unevaluated context?
+++# pragma GCC diagnostic ignored "-Wfloat-equal"
+++#endif
+++
+++#if defined( __clang__ )
+++# pragma clang diagnostic push
+++ // Did you know that comparing floats with `0` directly
+++ // is super-duper dangerous in unevaluated context?
+++# pragma clang diagnostic ignored "-Wfloat-equal"
+++#endif
+++
+++#define CATCH_DEFINE_COMPARABLE_TRAIT( id, op ) \
+++ template <typename, typename, typename = void> \
+++ struct is_##id##_comparable : std::false_type {}; \
+++ template <typename T, typename U> \
+++ struct is_##id##_comparable< \
+++ T, \
+++ U, \
+++ void_t<decltype( std::declval<T>() op std::declval<U>() )>> \
+++ : std::true_type {}; \
+++ template <typename, typename = void> \
+++ struct is_##id##_0_comparable : std::false_type {}; \
+++ template <typename T> \
+++ struct is_##id##_0_comparable<T, \
+++ void_t<decltype( std::declval<T>() op 0 )>> \
+++ : std::true_type {};
+++
+++ // We need all 6 pre-spaceship comparison ops: <, <=, >, >=, ==, !=
+++ CATCH_DEFINE_COMPARABLE_TRAIT( lt, < )
+++ CATCH_DEFINE_COMPARABLE_TRAIT( le, <= )
+++ CATCH_DEFINE_COMPARABLE_TRAIT( gt, > )
+++ CATCH_DEFINE_COMPARABLE_TRAIT( ge, >= )
+++ CATCH_DEFINE_COMPARABLE_TRAIT( eq, == )
+++ CATCH_DEFINE_COMPARABLE_TRAIT( ne, != )
+++
+++#undef CATCH_DEFINE_COMPARABLE_TRAIT
+++
+++#if defined( __GNUC__ ) && !defined( __clang__ )
+++# pragma GCC diagnostic pop
+++#endif
+++#if defined( __clang__ )
+++# pragma clang diagnostic pop
+++#endif
+++
+++
+++ } // namespace Detail
+++} // namespace Catch
+++
+++#endif // CATCH_COMPARE_TRAITS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_LOGICAL_TRAITS_HPP_INCLUDED
+++#define CATCH_LOGICAL_TRAITS_HPP_INCLUDED
+++
+++#include <type_traits>
+++
+++namespace Catch {
+++namespace Detail {
+++
+++#if defined( __cpp_lib_logical_traits ) && __cpp_lib_logical_traits >= 201510
+++
+++ using std::conjunction;
+++ using std::disjunction;
+++ using std::negation;
+++
+++#else
+++
+++ template <class...> struct conjunction : std::true_type {};
+++ template <class B1> struct conjunction<B1> : B1 {};
+++ template <class B1, class... Bn>
+++ struct conjunction<B1, Bn...>
+++ : std::conditional_t<bool( B1::value ), conjunction<Bn...>, B1> {};
+++
+++ template <class...> struct disjunction : std::false_type {};
+++ template <class B1> struct disjunction<B1> : B1 {};
+++ template <class B1, class... Bn>
+++ struct disjunction<B1, Bn...>
+++ : std::conditional_t<bool( B1::value ), B1, disjunction<Bn...>> {};
+++
+++ template <class B>
+++ struct negation : std::integral_constant<bool, !bool(B::value)> {};
+++
+++#endif
+++
+++} // namespace Detail
+++} // namespace Catch
+++
+++#endif // CATCH_LOGICAL_TRAITS_HPP_INCLUDED
+++
+++#include <type_traits>
+++#include <iosfwd>
+++
+++/** \file
+++ * Why does decomposing look the way it does:
+++ *
+++ * Conceptually, decomposing is simple. We change `REQUIRE( a == b )` into
+++ * `Decomposer{} <= a == b`, so that `Decomposer{} <= a` is evaluated first,
+++ * and our custom operator is used for `a == b`, because `a` is transformed
+++ * into `ExprLhs<T&>` and then into `BinaryExpr<T&, U&>`.
+++ *
+++ * In practice, decomposing ends up a mess, because we have to support
+++ * various fun things.
+++ *
+++ * 1) Types that are only comparable with literal 0, and they do this by
+++ * comparing against a magic type with pointer constructor and deleted
+++ * other constructors. Example: `REQUIRE((a <=> b) == 0)` in libstdc++
+++ *
+++ * 2) Types that are only comparable with literal 0, and they do this by
+++ * comparing against a magic type with consteval integer constructor.
+++ * Example: `REQUIRE((a <=> b) == 0)` in current MSVC STL.
+++ *
+++ * 3) Types that have no linkage, and so we cannot form a reference to
+++ * them. Example: some implementations of traits.
+++ *
+++ * 4) Starting with C++20, when the compiler sees `a == b`, it also uses
+++ * `b == a` when constructing the overload set. For us this means that
+++ * when the compiler handles `ExprLhs<T> == b`, it also tries to resolve
+++ * the overload set for `b == ExprLhs<T>`.
+++ *
+++ * To accomodate these use cases, decomposer ended up rather complex.
+++ *
+++ * 1) These types are handled by adding SFINAE overloads to our comparison
+++ * operators, checking whether `T == U` are comparable with the given
+++ * operator, and if not, whether T (or U) are comparable with literal 0.
+++ * If yes, the overload compares T (or U) with 0 literal inline in the
+++ * definition.
+++ *
+++ * Note that for extra correctness, we check that the other type is
+++ * either an `int` (literal 0 is captured as `int` by templates), or
+++ * a `long` (some platforms use 0L for `NULL` and we want to support
+++ * that for pointer comparisons).
+++ *
+++ * 2) For these types, `is_foo_comparable<T, int>` is true, but letting
+++ * them fall into the overload that actually does `T == int` causes
+++ * compilation error. Handling them requires that the decomposition
+++ * is `constexpr`, so that P2564R3 applies and the `consteval` from
+++ * their accompanying magic type is propagated through the `constexpr`
+++ * call stack.
+++ *
+++ * However this is not enough to handle these types automatically,
+++ * because our default is to capture types by reference, to avoid
+++ * runtime copies. While these references cannot become dangling,
+++ * they outlive the constexpr context and thus the default capture
+++ * path cannot be actually constexpr.
+++ *
+++ * The solution is to capture these types by value, by explicitly
+++ * specializing `Catch::capture_by_value` for them. Catch2 provides
+++ * specialization for `std::foo_ordering`s, but users can specialize
+++ * the trait for their own types as well.
+++ *
+++ * 3) If a type has no linkage, we also cannot capture it by reference.
+++ * The solution is once again to capture them by value. We handle
+++ * the common cases by using `std::is_arithmetic` as the default
+++ * for `Catch::capture_by_value`, but that is only a some-effort
+++ * heuristic. But as with 2), users can specialize `capture_by_value`
+++ * for their own types as needed.
+++ *
+++ * 4) To support C++20 and make the SFINAE on our decomposing operators
+++ * work, the SFINAE has to happen in return type, rather than in
+++ * a template type. This is due to our use of logical type traits
+++ * (`conjunction`/`disjunction`/`negation`), that we use to workaround
+++ * an issue in older (9-) versions of GCC. I still blame C++20 for
+++ * this, because without the comparison order switching, the logical
+++ * traits could still be used in template type.
+++ *
+++ * There are also other side concerns, e.g. supporting both `REQUIRE(a)`
+++ * and `REQUIRE(a == b)`, or making `REQUIRE_THAT(a, IsEqual(b))` slot
+++ * nicely into the same expression handling logic, but these are rather
+++ * straightforward and add only a bit of complexity (e.g. common base
+++ * class for decomposed expressions).
+++ */
+++
+++#ifdef _MSC_VER
+++#pragma warning(push)
+++#pragma warning(disable:4389) // '==' : signed/unsigned mismatch
+++#pragma warning(disable:4018) // more "signed/unsigned mismatch"
+++#pragma warning(disable:4312) // Converting int to T* using reinterpret_cast (issue on x64 platform)
+++#pragma warning(disable:4180) // qualifier applied to function type has no meaning
+++#pragma warning(disable:4800) // Forcing result to true or false
+++#endif
+++
+++#ifdef __clang__
+++# pragma clang diagnostic push
+++# pragma clang diagnostic ignored "-Wsign-compare"
+++# pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+++#elif defined __GNUC__
+++# pragma GCC diagnostic push
+++# pragma GCC diagnostic ignored "-Wsign-compare"
+++# pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+++#endif
+++
+++#if defined(CATCH_CPP20_OR_GREATER) && __has_include(<compare>)
+++# include <compare>
+++# if defined( __cpp_lib_three_way_comparison ) && \
+++ __cpp_lib_three_way_comparison >= 201907L
+++# define CATCH_CONFIG_CPP20_COMPARE_OVERLOADS
+++# endif
+++#endif
+++
+++namespace Catch {
+++
+++ namespace Detail {
+++ // This was added in C++20, but we require only C++14 for now.
+++ template <typename T>
+++ using RemoveCVRef_t = std::remove_cv_t<std::remove_reference_t<T>>;
+++ }
+++
+++ // Note: There is nothing that stops us from extending this,
+++ // e.g. to `std::is_scalar`, but the more encompassing
+++ // traits are usually also more expensive. For now we
+++ // keep this as it used to be and it can be changed later.
+++ template <typename T>
+++ struct capture_by_value
+++ : std::integral_constant<bool, std::is_arithmetic<T>{}> {};
+++
+++#if defined( CATCH_CONFIG_CPP20_COMPARE_OVERLOADS )
+++ template <>
+++ struct capture_by_value<std::strong_ordering> : std::true_type {};
+++ template <>
+++ struct capture_by_value<std::weak_ordering> : std::true_type {};
+++ template <>
+++ struct capture_by_value<std::partial_ordering> : std::true_type {};
+++#endif
+++
+++ template <typename T>
+++ struct always_false : std::false_type {};
+++
+++ class ITransientExpression {
+++ bool m_isBinaryExpression;
+++ bool m_result;
+++
+++ public:
+++ constexpr auto isBinaryExpression() const -> bool { return m_isBinaryExpression; }
+++ constexpr auto getResult() const -> bool { return m_result; }
+++ //! This function **has** to be overriden by the derived class.
+++ virtual void streamReconstructedExpression( std::ostream& os ) const;
+++
+++ constexpr ITransientExpression( bool isBinaryExpression, bool result )
+++ : m_isBinaryExpression( isBinaryExpression ),
+++ m_result( result )
+++ {}
+++
+++ ITransientExpression() = default;
+++ ITransientExpression(ITransientExpression const&) = default;
+++ ITransientExpression& operator=(ITransientExpression const&) = default;
+++
+++ friend std::ostream& operator<<(std::ostream& out, ITransientExpression const& expr) {
+++ expr.streamReconstructedExpression(out);
+++ return out;
+++ }
+++
+++ protected:
+++ ~ITransientExpression() = default;
+++ };
+++
+++ void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs );
+++
+++ template<typename LhsT, typename RhsT>
+++ class BinaryExpr : public ITransientExpression {
+++ LhsT m_lhs;
+++ StringRef m_op;
+++ RhsT m_rhs;
+++
+++ void streamReconstructedExpression( std::ostream &os ) const override {
+++ formatReconstructedExpression
+++ ( os, Catch::Detail::stringify( m_lhs ), m_op, Catch::Detail::stringify( m_rhs ) );
+++ }
+++
+++ public:
+++ constexpr BinaryExpr( bool comparisonResult, LhsT lhs, StringRef op, RhsT rhs )
+++ : ITransientExpression{ true, comparisonResult },
+++ m_lhs( lhs ),
+++ m_op( op ),
+++ m_rhs( rhs )
+++ {}
+++
+++ template<typename T>
+++ auto operator && ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+++ static_assert(always_false<T>::value,
+++ "chained comparisons are not supported inside assertions, "
+++ "wrap the expression inside parentheses, or decompose it");
+++ }
+++
+++ template<typename T>
+++ auto operator || ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+++ static_assert(always_false<T>::value,
+++ "chained comparisons are not supported inside assertions, "
+++ "wrap the expression inside parentheses, or decompose it");
+++ }
+++
+++ template<typename T>
+++ auto operator == ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+++ static_assert(always_false<T>::value,
+++ "chained comparisons are not supported inside assertions, "
+++ "wrap the expression inside parentheses, or decompose it");
+++ }
+++
+++ template<typename T>
+++ auto operator != ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+++ static_assert(always_false<T>::value,
+++ "chained comparisons are not supported inside assertions, "
+++ "wrap the expression inside parentheses, or decompose it");
+++ }
+++
+++ template<typename T>
+++ auto operator > ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+++ static_assert(always_false<T>::value,
+++ "chained comparisons are not supported inside assertions, "
+++ "wrap the expression inside parentheses, or decompose it");
+++ }
+++
+++ template<typename T>
+++ auto operator < ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+++ static_assert(always_false<T>::value,
+++ "chained comparisons are not supported inside assertions, "
+++ "wrap the expression inside parentheses, or decompose it");
+++ }
+++
+++ template<typename T>
+++ auto operator >= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+++ static_assert(always_false<T>::value,
+++ "chained comparisons are not supported inside assertions, "
+++ "wrap the expression inside parentheses, or decompose it");
+++ }
+++
+++ template<typename T>
+++ auto operator <= ( T ) const -> BinaryExpr<LhsT, RhsT const&> const {
+++ static_assert(always_false<T>::value,
+++ "chained comparisons are not supported inside assertions, "
+++ "wrap the expression inside parentheses, or decompose it");
+++ }
+++ };
+++
+++ template<typename LhsT>
+++ class UnaryExpr : public ITransientExpression {
+++ LhsT m_lhs;
+++
+++ void streamReconstructedExpression( std::ostream &os ) const override {
+++ os << Catch::Detail::stringify( m_lhs );
+++ }
+++
+++ public:
+++ explicit constexpr UnaryExpr( LhsT lhs )
+++ : ITransientExpression{ false, static_cast<bool>(lhs) },
+++ m_lhs( lhs )
+++ {}
+++ };
+++
+++
+++ template<typename LhsT>
+++ class ExprLhs {
+++ LhsT m_lhs;
+++ public:
+++ explicit constexpr ExprLhs( LhsT lhs ) : m_lhs( lhs ) {}
+++
+++#define CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( id, op ) \
+++ template <typename RhsT> \
+++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \
+++ -> std::enable_if_t< \
+++ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
+++ Detail::negation<capture_by_value< \
+++ Detail::RemoveCVRef_t<RhsT>>>>::value, \
+++ BinaryExpr<LhsT, RhsT const&>> { \
+++ return { \
+++ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+++ } \
+++ template <typename RhsT> \
+++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+++ -> std::enable_if_t< \
+++ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
+++ capture_by_value<RhsT>>::value, \
+++ BinaryExpr<LhsT, RhsT>> { \
+++ return { \
+++ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+++ } \
+++ template <typename RhsT> \
+++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+++ -> std::enable_if_t< \
+++ Detail::conjunction< \
+++ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
+++ Detail::is_eq_0_comparable<LhsT>, \
+++ /* We allow long because we want `ptr op NULL` to be accepted */ \
+++ Detail::disjunction<std::is_same<RhsT, int>, \
+++ std::is_same<RhsT, long>>>::value, \
+++ BinaryExpr<LhsT, RhsT>> { \
+++ if ( rhs != 0 ) { throw_test_failure_exception(); } \
+++ return { \
+++ static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs }; \
+++ } \
+++ template <typename RhsT> \
+++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+++ -> std::enable_if_t< \
+++ Detail::conjunction< \
+++ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
+++ Detail::is_eq_0_comparable<RhsT>, \
+++ /* We allow long because we want `ptr op NULL` to be accepted */ \
+++ Detail::disjunction<std::is_same<LhsT, int>, \
+++ std::is_same<LhsT, long>>>::value, \
+++ BinaryExpr<LhsT, RhsT>> { \
+++ if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); } \
+++ return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+++ }
+++
+++ CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( eq, == )
+++ CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR( ne, != )
+++
+++ #undef CATCH_INTERNAL_DEFINE_EXPRESSION_EQUALITY_OPERATOR
+++
+++
+++#define CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( id, op ) \
+++ template <typename RhsT> \
+++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \
+++ -> std::enable_if_t< \
+++ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
+++ Detail::negation<capture_by_value< \
+++ Detail::RemoveCVRef_t<RhsT>>>>::value, \
+++ BinaryExpr<LhsT, RhsT const&>> { \
+++ return { \
+++ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+++ } \
+++ template <typename RhsT> \
+++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+++ -> std::enable_if_t< \
+++ Detail::conjunction<Detail::is_##id##_comparable<LhsT, RhsT>, \
+++ capture_by_value<RhsT>>::value, \
+++ BinaryExpr<LhsT, RhsT>> { \
+++ return { \
+++ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+++ } \
+++ template <typename RhsT> \
+++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+++ -> std::enable_if_t< \
+++ Detail::conjunction< \
+++ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
+++ Detail::is_##id##_0_comparable<LhsT>, \
+++ std::is_same<RhsT, int>>::value, \
+++ BinaryExpr<LhsT, RhsT>> { \
+++ if ( rhs != 0 ) { throw_test_failure_exception(); } \
+++ return { \
+++ static_cast<bool>( lhs.m_lhs op 0 ), lhs.m_lhs, #op##_sr, rhs }; \
+++ } \
+++ template <typename RhsT> \
+++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+++ -> std::enable_if_t< \
+++ Detail::conjunction< \
+++ Detail::negation<Detail::is_##id##_comparable<LhsT, RhsT>>, \
+++ Detail::is_##id##_0_comparable<RhsT>, \
+++ std::is_same<LhsT, int>>::value, \
+++ BinaryExpr<LhsT, RhsT>> { \
+++ if ( lhs.m_lhs != 0 ) { throw_test_failure_exception(); } \
+++ return { static_cast<bool>( 0 op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+++ }
+++
+++ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( lt, < )
+++ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( le, <= )
+++ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( gt, > )
+++ CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR( ge, >= )
+++
+++ #undef CATCH_INTERNAL_DEFINE_EXPRESSION_COMPARISON_OPERATOR
+++
+++
+++#define CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR( op ) \
+++ template <typename RhsT> \
+++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT&& rhs ) \
+++ -> std::enable_if_t< \
+++ !capture_by_value<Detail::RemoveCVRef_t<RhsT>>::value, \
+++ BinaryExpr<LhsT, RhsT const&>> { \
+++ return { \
+++ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+++ } \
+++ template <typename RhsT> \
+++ constexpr friend auto operator op( ExprLhs&& lhs, RhsT rhs ) \
+++ -> std::enable_if_t<capture_by_value<RhsT>::value, \
+++ BinaryExpr<LhsT, RhsT>> { \
+++ return { \
+++ static_cast<bool>( lhs.m_lhs op rhs ), lhs.m_lhs, #op##_sr, rhs }; \
+++ }
+++
+++ CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(|)
+++ CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(&)
+++ CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR(^)
+++
+++ #undef CATCH_INTERNAL_DEFINE_EXPRESSION_OPERATOR
+++
+++ template<typename RhsT>
+++ friend auto operator && ( ExprLhs &&, RhsT && ) -> BinaryExpr<LhsT, RhsT const&> {
+++ static_assert(always_false<RhsT>::value,
+++ "operator&& is not supported inside assertions, "
+++ "wrap the expression inside parentheses, or decompose it");
+++ }
+++
+++ template<typename RhsT>
+++ friend auto operator || ( ExprLhs &&, RhsT && ) -> BinaryExpr<LhsT, RhsT const&> {
+++ static_assert(always_false<RhsT>::value,
+++ "operator|| is not supported inside assertions, "
+++ "wrap the expression inside parentheses, or decompose it");
+++ }
+++
+++ constexpr auto makeUnaryExpr() const -> UnaryExpr<LhsT> {
+++ return UnaryExpr<LhsT>{ m_lhs };
+++ }
+++ };
+++
+++ struct Decomposer {
+++ template <typename T,
+++ std::enable_if_t<!capture_by_value<Detail::RemoveCVRef_t<T>>::value,
+++ int> = 0>
+++ constexpr friend auto operator <= ( Decomposer &&, T && lhs ) -> ExprLhs<T const&> {
+++ return ExprLhs<const T&>{ lhs };
+++ }
+++
+++ template <typename T,
+++ std::enable_if_t<capture_by_value<T>::value, int> = 0>
+++ constexpr friend auto operator <= ( Decomposer &&, T value ) -> ExprLhs<T> {
+++ return ExprLhs<T>{ value };
+++ }
+++ };
+++
+++} // end namespace Catch
+++
+++#ifdef _MSC_VER
+++#pragma warning(pop)
+++#endif
+++#ifdef __clang__
+++# pragma clang diagnostic pop
+++#elif defined __GNUC__
+++# pragma GCC diagnostic pop
+++#endif
+++
+++#endif // CATCH_DECOMPOSER_HPP_INCLUDED
+++
+++#include <string>
+++
+++namespace Catch {
+++
+++ struct AssertionReaction {
+++ bool shouldDebugBreak = false;
+++ bool shouldThrow = false;
+++ bool shouldSkip = false;
+++ };
+++
+++ class AssertionHandler {
+++ AssertionInfo m_assertionInfo;
+++ AssertionReaction m_reaction;
+++ bool m_completed = false;
+++ IResultCapture& m_resultCapture;
+++
+++ public:
+++ AssertionHandler
+++ ( StringRef macroName,
+++ SourceLineInfo const& lineInfo,
+++ StringRef capturedExpression,
+++ ResultDisposition::Flags resultDisposition );
+++ ~AssertionHandler() {
+++ if ( !m_completed ) {
+++ m_resultCapture.handleIncomplete( m_assertionInfo );
+++ }
+++ }
+++
+++
+++ template<typename T>
+++ void handleExpr( ExprLhs<T> const& expr ) {
+++ handleExpr( expr.makeUnaryExpr() );
+++ }
+++ void handleExpr( ITransientExpression const& expr );
+++
+++ void handleMessage(ResultWas::OfType resultType, StringRef message);
+++
+++ void handleExceptionThrownAsExpected();
+++ void handleUnexpectedExceptionNotThrown();
+++ void handleExceptionNotThrownAsExpected();
+++ void handleThrowingCallSkipped();
+++ void handleUnexpectedInflightException();
+++
+++ void complete();
+++
+++ // query
+++ auto allowThrows() const -> bool;
+++ };
+++
+++ void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str );
+++
+++} // namespace Catch
+++
+++#endif // CATCH_ASSERTION_HANDLER_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
+++#define CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
+++
+++
+++#if !defined(CATCH_CONFIG_DISABLE_STRINGIFICATION)
+++ #define CATCH_INTERNAL_STRINGIFY(...) #__VA_ARGS__##_catch_sr
+++#else
+++ #define CATCH_INTERNAL_STRINGIFY(...) "Disabled by CATCH_CONFIG_DISABLE_STRINGIFICATION"_catch_sr
+++#endif
+++
+++#endif // CATCH_PREPROCESSOR_INTERNAL_STRINGIFY_HPP_INCLUDED
+++
+++// We need this suppression to leak, because it took until GCC 10
+++// for the front end to handle local suppression via _Pragma properly
+++#if defined(__GNUC__) && !defined(__clang__) && !defined(__ICC) && __GNUC__ <= 9
+++ #pragma GCC diagnostic ignored "-Wparentheses"
+++#endif
+++
+++#if !defined(CATCH_CONFIG_DISABLE)
+++
+++#if defined(CATCH_CONFIG_FAST_COMPILE) || defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+++
+++///////////////////////////////////////////////////////////////////////////////
+++// Another way to speed-up compilation is to omit local try-catch for REQUIRE*
+++// macros.
+++#define INTERNAL_CATCH_TRY
+++#define INTERNAL_CATCH_CATCH( capturer )
+++
+++#else // CATCH_CONFIG_FAST_COMPILE
+++
+++#define INTERNAL_CATCH_TRY try
+++#define INTERNAL_CATCH_CATCH( handler ) catch(...) { (handler).handleUnexpectedInflightException(); }
+++
+++#endif
+++
+++#define INTERNAL_CATCH_REACT( handler ) handler.complete();
+++
+++///////////////////////////////////////////////////////////////////////////////
+++#define INTERNAL_CATCH_TEST( macroName, resultDisposition, ... ) \
+++ do { /* NOLINT(bugprone-infinite-loop) */ \
+++ /* The expression should not be evaluated, but warnings should hopefully be checked */ \
+++ CATCH_INTERNAL_IGNORE_BUT_WARN(__VA_ARGS__); \
+++ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+++ INTERNAL_CATCH_TRY { \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_PARENTHESES_WARNINGS \
+++ catchAssertionHandler.handleExpr( Catch::Decomposer() <= __VA_ARGS__ ); /* NOLINT(bugprone-chained-comparison) */ \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+++ } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+++ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+++ } while( (void)0, (false) && static_cast<const bool&>( !!(__VA_ARGS__) ) ) // the expression here is never evaluated at runtime but it forces the compiler to give it a look
+++ // The double negation silences MSVC's C4800 warning, the static_cast forces short-circuit evaluation if the type has overloaded &&.
+++
+++///////////////////////////////////////////////////////////////////////////////
+++#define INTERNAL_CATCH_IF( macroName, resultDisposition, ... ) \
+++ INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
+++ if( Catch::getResultCapture().lastAssertionPassed() )
+++
+++///////////////////////////////////////////////////////////////////////////////
+++#define INTERNAL_CATCH_ELSE( macroName, resultDisposition, ... ) \
+++ INTERNAL_CATCH_TEST( macroName, resultDisposition, __VA_ARGS__ ); \
+++ if( !Catch::getResultCapture().lastAssertionPassed() )
+++
+++///////////////////////////////////////////////////////////////////////////////
+++#define INTERNAL_CATCH_NO_THROW( macroName, resultDisposition, ... ) \
+++ do { \
+++ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition ); \
+++ try { \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+++ static_cast<void>(__VA_ARGS__); \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+++ catchAssertionHandler.handleExceptionNotThrownAsExpected(); \
+++ } \
+++ catch( ... ) { \
+++ catchAssertionHandler.handleUnexpectedInflightException(); \
+++ } \
+++ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+++ } while( false )
+++
+++///////////////////////////////////////////////////////////////////////////////
+++#define INTERNAL_CATCH_THROWS( macroName, resultDisposition, ... ) \
+++ do { \
+++ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__), resultDisposition); \
+++ if( catchAssertionHandler.allowThrows() ) \
+++ try { \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
+++ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+++ static_cast<void>(__VA_ARGS__); \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+++ catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+++ } \
+++ catch( ... ) { \
+++ catchAssertionHandler.handleExceptionThrownAsExpected(); \
+++ } \
+++ else \
+++ catchAssertionHandler.handleThrowingCallSkipped(); \
+++ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+++ } while( false )
+++
+++///////////////////////////////////////////////////////////////////////////////
+++#define INTERNAL_CATCH_THROWS_AS( macroName, exceptionType, resultDisposition, expr ) \
+++ do { \
+++ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(expr) ", " CATCH_INTERNAL_STRINGIFY(exceptionType), resultDisposition ); \
+++ if( catchAssertionHandler.allowThrows() ) \
+++ try { \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
+++ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+++ static_cast<void>(expr); \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+++ catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+++ } \
+++ catch( exceptionType const& ) { \
+++ catchAssertionHandler.handleExceptionThrownAsExpected(); \
+++ } \
+++ catch( ... ) { \
+++ catchAssertionHandler.handleUnexpectedInflightException(); \
+++ } \
+++ else \
+++ catchAssertionHandler.handleThrowingCallSkipped(); \
+++ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+++ } while( false )
+++
+++
+++
+++///////////////////////////////////////////////////////////////////////////////
+++// Although this is matcher-based, it can be used with just a string
+++#define INTERNAL_CATCH_THROWS_STR_MATCHES( macroName, resultDisposition, matcher, ... ) \
+++ do { \
+++ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+++ if( catchAssertionHandler.allowThrows() ) \
+++ try { \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_RESULT \
+++ CATCH_INTERNAL_SUPPRESS_USELESS_CAST_WARNINGS \
+++ static_cast<void>(__VA_ARGS__); \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+++ catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+++ } \
+++ catch( ... ) { \
+++ Catch::handleExceptionMatchExpr( catchAssertionHandler, matcher ); \
+++ } \
+++ else \
+++ catchAssertionHandler.handleThrowingCallSkipped(); \
+++ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+++ } while( false )
+++
+++#endif // CATCH_CONFIG_DISABLE
+++
+++#endif // CATCH_TEST_MACRO_IMPL_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_SECTION_HPP_INCLUDED
+++#define CATCH_SECTION_HPP_INCLUDED
+++
+++
+++
+++
+++/** \file
+++ * Wrapper for the STATIC_ANALYSIS_SUPPORT configuration option
+++ *
+++ * Some of Catch2's macros can be defined differently to work better with
+++ * static analysis tools, like clang-tidy or coverity.
+++ * Currently the main use case is to show that `SECTION`s are executed
+++ * exclusively, and not all in one run of a `TEST_CASE`.
+++ */
+++
+++#ifndef CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
+++#define CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
+++
+++
+++#if defined(__clang_analyzer__) || defined(__COVERITY__)
+++ #define CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT
+++#endif
+++
+++#if defined( CATCH_INTERNAL_CONFIG_STATIC_ANALYSIS_SUPPORT ) && \
+++ !defined( CATCH_CONFIG_NO_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT ) && \
+++ !defined( CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT )
+++# define CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
+++#endif
+++
+++
+++#endif // CATCH_CONFIG_STATIC_ANALYSIS_SUPPORT_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_TIMER_HPP_INCLUDED
+++#define CATCH_TIMER_HPP_INCLUDED
+++
+++#include <cstdint>
+++
+++namespace Catch {
+++
+++ class Timer {
+++ uint64_t m_nanoseconds = 0;
+++ public:
+++ void start();
+++ auto getElapsedNanoseconds() const -> uint64_t;
+++ auto getElapsedMicroseconds() const -> uint64_t;
+++ auto getElapsedMilliseconds() const -> unsigned int;
+++ auto getElapsedSeconds() const -> double;
+++ };
+++
+++} // namespace Catch
+++
+++#endif // CATCH_TIMER_HPP_INCLUDED
+++
+++namespace Catch {
+++
+++ class Section : Detail::NonCopyable {
+++ public:
+++ Section( SectionInfo&& info );
+++ Section( SourceLineInfo const& _lineInfo,
+++ StringRef _name,
+++ const char* const = nullptr );
+++ ~Section();
+++
+++ // This indicates whether the section should be executed or not
+++ explicit operator bool() const;
+++
+++ private:
+++ SectionInfo m_info;
+++
+++ Counts m_assertions;
+++ bool m_sectionIncluded;
+++ Timer m_timer;
+++ };
+++
+++} // end namespace Catch
+++
+++#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT)
+++# define INTERNAL_CATCH_SECTION( ... ) \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( \
+++ catch_internal_Section ) = \
+++ Catch::Section( CATCH_INTERNAL_LINEINFO, __VA_ARGS__ ) ) \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+++
+++# define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ if ( Catch::Section const& INTERNAL_CATCH_UNIQUE_NAME( \
+++ catch_internal_Section ) = \
+++ Catch::SectionInfo( \
+++ CATCH_INTERNAL_LINEINFO, \
+++ ( Catch::ReusableStringStream() << __VA_ARGS__ ) \
+++ .str() ) ) \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+++
+++#else
+++
+++// These section definitions imply that at most one section at one level
+++// will be intered (because only one section's __LINE__ can be equal to
+++// the dummy `catchInternalSectionHint` variable from `TEST_CASE`).
+++
+++namespace Catch {
+++ namespace Detail {
+++ // Intentionally without linkage, as it should only be used as a dummy
+++ // symbol for static analysis.
+++ // The arguments are used as a dummy for checking warnings in the passed
+++ // expressions.
+++ int GetNewSectionHint( StringRef, const char* const = nullptr );
+++ } // namespace Detail
+++} // namespace Catch
+++
+++
+++# define INTERNAL_CATCH_SECTION( ... ) \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+++ if ( [[maybe_unused]] const int catchInternalPreviousSectionHint = \
+++ catchInternalSectionHint, \
+++ catchInternalSectionHint = \
+++ Catch::Detail::GetNewSectionHint(__VA_ARGS__); \
+++ catchInternalPreviousSectionHint == __LINE__ ) \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+++
+++# define INTERNAL_CATCH_DYNAMIC_SECTION( ... ) \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+++ if ( [[maybe_unused]] const int catchInternalPreviousSectionHint = \
+++ catchInternalSectionHint, \
+++ catchInternalSectionHint = Catch::Detail::GetNewSectionHint( \
+++ ( Catch::ReusableStringStream() << __VA_ARGS__ ).str()); \
+++ catchInternalPreviousSectionHint == __LINE__ ) \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+++
+++#endif
+++
+++
+++#endif // CATCH_SECTION_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_TEST_REGISTRY_HPP_INCLUDED
+++#define CATCH_TEST_REGISTRY_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
+++#define CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
+++
+++namespace Catch {
+++
+++ class ITestInvoker {
+++ public:
+++ virtual void invoke() const = 0;
+++ virtual ~ITestInvoker(); // = default
+++ };
+++
+++} // namespace Catch
+++
+++#endif // CATCH_INTERFACES_TEST_INVOKER_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
+++#define CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
+++
+++#define INTERNAL_CATCH_EXPAND1( param ) INTERNAL_CATCH_EXPAND2( param )
+++#define INTERNAL_CATCH_EXPAND2( ... ) INTERNAL_CATCH_NO##__VA_ARGS__
+++#define INTERNAL_CATCH_DEF( ... ) INTERNAL_CATCH_DEF __VA_ARGS__
+++#define INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+++
+++#define INTERNAL_CATCH_REMOVE_PARENS( ... ) \
+++ INTERNAL_CATCH_EXPAND1( INTERNAL_CATCH_DEF __VA_ARGS__ )
+++
+++#endif // CATCH_PREPROCESSOR_REMOVE_PARENS_HPP_INCLUDED
+++
+++// GCC 5 and older do not properly handle disabling unused-variable warning
+++// with a _Pragma. This means that we have to leak the suppression to the
+++// user code as well :-(
+++#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5
+++#pragma GCC diagnostic ignored "-Wunused-variable"
+++#endif
+++
+++
+++
+++namespace Catch {
+++
+++template<typename C>
+++class TestInvokerAsMethod : public ITestInvoker {
+++ void (C::*m_testAsMethod)();
+++public:
+++ TestInvokerAsMethod( void (C::*testAsMethod)() ) noexcept : m_testAsMethod( testAsMethod ) {}
+++
+++ void invoke() const override {
+++ C obj;
+++ (obj.*m_testAsMethod)();
+++ }
+++};
+++
+++Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction)() );
+++
+++template<typename C>
+++Detail::unique_ptr<ITestInvoker> makeTestInvoker( void (C::*testAsMethod)() ) {
+++ return Detail::make_unique<TestInvokerAsMethod<C>>( testAsMethod );
+++}
+++
+++struct NameAndTags {
+++ constexpr NameAndTags( StringRef name_ = StringRef(),
+++ StringRef tags_ = StringRef() ) noexcept:
+++ name( name_ ), tags( tags_ ) {}
+++ StringRef name;
+++ StringRef tags;
+++};
+++
+++struct AutoReg : Detail::NonCopyable {
+++ AutoReg( Detail::unique_ptr<ITestInvoker> invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept;
+++};
+++
+++} // end namespace Catch
+++
+++#if defined(CATCH_CONFIG_DISABLE)
+++ #define INTERNAL_CATCH_TESTCASE_NO_REGISTRATION( TestName, ... ) \
+++ static inline void TestName()
+++ #define INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION( TestName, ClassName, ... ) \
+++ namespace{ \
+++ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
+++ void test(); \
+++ }; \
+++ } \
+++ void TestName::test()
+++#endif
+++
+++
+++#if !defined(CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT)
+++
+++ ///////////////////////////////////////////////////////////////////////////////
+++ #define INTERNAL_CATCH_TESTCASE2( TestName, ... ) \
+++ static void TestName(); \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ namespace{ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( &TestName ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); } /* NOLINT */ \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+++ static void TestName()
+++ #define INTERNAL_CATCH_TESTCASE( ... ) \
+++ INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__ )
+++
+++#else // ^^ !CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT | vv CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
+++
+++
+++// Dummy registrator for the dumy test case macros
+++namespace Catch {
+++ namespace Detail {
+++ struct DummyUse {
+++ DummyUse( void ( * )( int ), Catch::NameAndTags const& );
+++ };
+++ } // namespace Detail
+++} // namespace Catch
+++
+++// Note that both the presence of the argument and its exact name are
+++// necessary for the section support.
+++
+++// We provide a shadowed variable so that a `SECTION` inside non-`TEST_CASE`
+++// tests can compile. The redefined `TEST_CASE` shadows this with param.
+++static int catchInternalSectionHint = 0;
+++
+++# define INTERNAL_CATCH_TESTCASE2( fname, ... ) \
+++ static void fname( int ); \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ static const Catch::Detail::DummyUse INTERNAL_CATCH_UNIQUE_NAME( \
+++ dummyUser )( &(fname), Catch::NameAndTags{ __VA_ARGS__ } ); \
+++ CATCH_INTERNAL_SUPPRESS_SHADOW_WARNINGS \
+++ static void fname( [[maybe_unused]] int catchInternalSectionHint ) \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+++# define INTERNAL_CATCH_TESTCASE( ... ) \
+++ INTERNAL_CATCH_TESTCASE2( INTERNAL_CATCH_UNIQUE_NAME( dummyFunction ), __VA_ARGS__ )
+++
+++
+++#endif // CATCH_CONFIG_EXPERIMENTAL_STATIC_ANALYSIS_SUPPORT
+++
+++ ///////////////////////////////////////////////////////////////////////////////
+++ #define INTERNAL_CATCH_TEST_CASE_METHOD2( TestName, ClassName, ... )\
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ namespace{ \
+++ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName) { \
+++ void test(); \
+++ }; \
+++ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
+++ Catch::makeTestInvoker( &TestName::test ), \
+++ CATCH_INTERNAL_LINEINFO, \
+++ #ClassName##_catch_sr, \
+++ Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+++ } \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+++ void TestName::test()
+++ #define INTERNAL_CATCH_TEST_CASE_METHOD( ClassName, ... ) \
+++ INTERNAL_CATCH_TEST_CASE_METHOD2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), ClassName, __VA_ARGS__ )
+++
+++
+++ ///////////////////////////////////////////////////////////////////////////////
+++ #define INTERNAL_CATCH_METHOD_AS_TEST_CASE( QualifiedMethod, ... ) \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ namespace { \
+++ const Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( \
+++ Catch::makeTestInvoker( &QualifiedMethod ), \
+++ CATCH_INTERNAL_LINEINFO, \
+++ "&" #QualifiedMethod##_catch_sr, \
+++ Catch::NameAndTags{ __VA_ARGS__ } ); \
+++ } /* NOLINT */ \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+++
+++
+++ ///////////////////////////////////////////////////////////////////////////////
+++ #define INTERNAL_CATCH_REGISTER_TESTCASE( Function, ... ) \
+++ do { \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ Catch::AutoReg INTERNAL_CATCH_UNIQUE_NAME( autoRegistrar )( Catch::makeTestInvoker( Function ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ __VA_ARGS__ } ); /* NOLINT */ \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+++ } while(false)
+++
+++
+++#endif // CATCH_TEST_REGISTRY_HPP_INCLUDED
+++
+++
+++// All of our user-facing macros support configuration toggle, that
+++// forces them to be defined prefixed with CATCH_. We also like to
+++// support another toggle that can minimize (disable) their implementation.
+++// Given this, we have 4 different configuration options below
+++
+++#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+++
+++ #define CATCH_REQUIRE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+++ #define CATCH_REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+++
+++ #define CATCH_REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+++ #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+++ #define CATCH_REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+++
+++ #define CATCH_CHECK( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+++ #define CATCH_CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+++ #define CATCH_CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CATCH_CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+++ #define CATCH_CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CATCH_CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+++ #define CATCH_CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CATCH_CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+++
+++ #define CATCH_CHECK_THROWS( ... ) INTERNAL_CATCH_THROWS( "CATCH_CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+++ #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CATCH_CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+++ #define CATCH_CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CATCH_CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+++
+++ #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+++ #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+++ #define CATCH_METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+++ #define CATCH_REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+++ #define CATCH_SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+++ #define CATCH_DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
+++ #define CATCH_FAIL( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+++ #define CATCH_FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "CATCH_FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+++ #define CATCH_SUCCEED( ... ) INTERNAL_CATCH_MSG( "CATCH_SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+++ #define CATCH_SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+++
+++
+++ #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+++ #define CATCH_STATIC_REQUIRE( ... ) static_assert( __VA_ARGS__ , #__VA_ARGS__ ); CATCH_SUCCEED( #__VA_ARGS__ )
+++ #define CATCH_STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
+++ #define CATCH_STATIC_CHECK( ... ) static_assert( __VA_ARGS__ , #__VA_ARGS__ ); CATCH_SUCCEED( #__VA_ARGS__ )
+++ #define CATCH_STATIC_CHECK_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); CATCH_SUCCEED( #__VA_ARGS__ )
+++ #else
+++ #define CATCH_STATIC_REQUIRE( ... ) CATCH_REQUIRE( __VA_ARGS__ )
+++ #define CATCH_STATIC_REQUIRE_FALSE( ... ) CATCH_REQUIRE_FALSE( __VA_ARGS__ )
+++ #define CATCH_STATIC_CHECK( ... ) CATCH_CHECK( __VA_ARGS__ )
+++ #define CATCH_STATIC_CHECK_FALSE( ... ) CATCH_CHECK_FALSE( __VA_ARGS__ )
+++ #endif
+++
+++
+++ // "BDD-style" convenience wrappers
+++ #define CATCH_SCENARIO( ... ) CATCH_TEST_CASE( "Scenario: " __VA_ARGS__ )
+++ #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+++ #define CATCH_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Given: " << desc )
+++ #define CATCH_AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+++ #define CATCH_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " When: " << desc )
+++ #define CATCH_AND_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+++ #define CATCH_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Then: " << desc )
+++ #define CATCH_AND_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And: " << desc )
+++
+++#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE) // ^^ prefixed, implemented | vv prefixed, disabled
+++
+++ #define CATCH_REQUIRE( ... ) (void)(0)
+++ #define CATCH_REQUIRE_FALSE( ... ) (void)(0)
+++
+++ #define CATCH_REQUIRE_THROWS( ... ) (void)(0)
+++ #define CATCH_REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+++ #define CATCH_REQUIRE_NOTHROW( ... ) (void)(0)
+++
+++ #define CATCH_CHECK( ... ) (void)(0)
+++ #define CATCH_CHECK_FALSE( ... ) (void)(0)
+++ #define CATCH_CHECKED_IF( ... ) if (__VA_ARGS__)
+++ #define CATCH_CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
+++ #define CATCH_CHECK_NOFAIL( ... ) (void)(0)
+++
+++ #define CATCH_CHECK_THROWS( ... ) (void)(0)
+++ #define CATCH_CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+++ #define CATCH_CHECK_NOTHROW( ... ) (void)(0)
+++
+++ #define CATCH_TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+++ #define CATCH_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+++ #define CATCH_METHOD_AS_TEST_CASE( method, ... )
+++ #define CATCH_REGISTER_TEST_CASE( Function, ... ) (void)(0)
+++ #define CATCH_SECTION( ... )
+++ #define CATCH_DYNAMIC_SECTION( ... )
+++ #define CATCH_FAIL( ... ) (void)(0)
+++ #define CATCH_FAIL_CHECK( ... ) (void)(0)
+++ #define CATCH_SUCCEED( ... ) (void)(0)
+++ #define CATCH_SKIP( ... ) (void)(0)
+++
+++ #define CATCH_STATIC_REQUIRE( ... ) (void)(0)
+++ #define CATCH_STATIC_REQUIRE_FALSE( ... ) (void)(0)
+++ #define CATCH_STATIC_CHECK( ... ) (void)(0)
+++ #define CATCH_STATIC_CHECK_FALSE( ... ) (void)(0)
+++
+++ // "BDD-style" convenience wrappers
+++ #define CATCH_SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+++ #define CATCH_SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), className )
+++ #define CATCH_GIVEN( desc )
+++ #define CATCH_AND_GIVEN( desc )
+++ #define CATCH_WHEN( desc )
+++ #define CATCH_AND_WHEN( desc )
+++ #define CATCH_THEN( desc )
+++ #define CATCH_AND_THEN( desc )
+++
+++#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE) // ^^ prefixed, disabled | vv unprefixed, implemented
+++
+++ #define REQUIRE( ... ) INTERNAL_CATCH_TEST( "REQUIRE", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+++ #define REQUIRE_FALSE( ... ) INTERNAL_CATCH_TEST( "REQUIRE_FALSE", Catch::ResultDisposition::Normal | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+++
+++ #define REQUIRE_THROWS( ... ) INTERNAL_CATCH_THROWS( "REQUIRE_THROWS", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+++ #define REQUIRE_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "REQUIRE_THROWS_AS", exceptionType, Catch::ResultDisposition::Normal, expr )
+++ #define REQUIRE_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "REQUIRE_NOTHROW", Catch::ResultDisposition::Normal, __VA_ARGS__ )
+++
+++ #define CHECK( ... ) INTERNAL_CATCH_TEST( "CHECK", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+++ #define CHECK_FALSE( ... ) INTERNAL_CATCH_TEST( "CHECK_FALSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::FalseTest, __VA_ARGS__ )
+++ #define CHECKED_IF( ... ) INTERNAL_CATCH_IF( "CHECKED_IF", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+++ #define CHECKED_ELSE( ... ) INTERNAL_CATCH_ELSE( "CHECKED_ELSE", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+++ #define CHECK_NOFAIL( ... ) INTERNAL_CATCH_TEST( "CHECK_NOFAIL", Catch::ResultDisposition::ContinueOnFailure | Catch::ResultDisposition::SuppressFail, __VA_ARGS__ )
+++
+++ #define CHECK_THROWS( ... ) INTERNAL_CATCH_THROWS( "CHECK_THROWS", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+++ #define CHECK_THROWS_AS( expr, exceptionType ) INTERNAL_CATCH_THROWS_AS( "CHECK_THROWS_AS", exceptionType, Catch::ResultDisposition::ContinueOnFailure, expr )
+++ #define CHECK_NOTHROW( ... ) INTERNAL_CATCH_NO_THROW( "CHECK_NOTHROW", Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+++
+++ #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE( __VA_ARGS__ )
+++ #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, __VA_ARGS__ )
+++ #define METHOD_AS_TEST_CASE( method, ... ) INTERNAL_CATCH_METHOD_AS_TEST_CASE( method, __VA_ARGS__ )
+++ #define REGISTER_TEST_CASE( Function, ... ) INTERNAL_CATCH_REGISTER_TESTCASE( Function, __VA_ARGS__ )
+++ #define SECTION( ... ) INTERNAL_CATCH_SECTION( __VA_ARGS__ )
+++ #define DYNAMIC_SECTION( ... ) INTERNAL_CATCH_DYNAMIC_SECTION( __VA_ARGS__ )
+++ #define FAIL( ... ) INTERNAL_CATCH_MSG( "FAIL", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+++ #define FAIL_CHECK( ... ) INTERNAL_CATCH_MSG( "FAIL_CHECK", Catch::ResultWas::ExplicitFailure, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+++ #define SUCCEED( ... ) INTERNAL_CATCH_MSG( "SUCCEED", Catch::ResultWas::Ok, Catch::ResultDisposition::ContinueOnFailure, __VA_ARGS__ )
+++ #define SKIP( ... ) INTERNAL_CATCH_MSG( "SKIP", Catch::ResultWas::ExplicitSkip, Catch::ResultDisposition::Normal, __VA_ARGS__ )
+++
+++
+++ #if !defined(CATCH_CONFIG_RUNTIME_STATIC_REQUIRE)
+++ #define STATIC_REQUIRE( ... ) static_assert( __VA_ARGS__, #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
+++ #define STATIC_REQUIRE_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
+++ #define STATIC_CHECK( ... ) static_assert( __VA_ARGS__, #__VA_ARGS__ ); SUCCEED( #__VA_ARGS__ )
+++ #define STATIC_CHECK_FALSE( ... ) static_assert( !(__VA_ARGS__), "!(" #__VA_ARGS__ ")" ); SUCCEED( "!(" #__VA_ARGS__ ")" )
+++ #else
+++ #define STATIC_REQUIRE( ... ) REQUIRE( __VA_ARGS__ )
+++ #define STATIC_REQUIRE_FALSE( ... ) REQUIRE_FALSE( __VA_ARGS__ )
+++ #define STATIC_CHECK( ... ) CHECK( __VA_ARGS__ )
+++ #define STATIC_CHECK_FALSE( ... ) CHECK_FALSE( __VA_ARGS__ )
+++ #endif
+++
+++ // "BDD-style" convenience wrappers
+++ #define SCENARIO( ... ) TEST_CASE( "Scenario: " __VA_ARGS__ )
+++ #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TEST_CASE_METHOD( className, "Scenario: " __VA_ARGS__ )
+++ #define GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Given: " << desc )
+++ #define AND_GIVEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( "And given: " << desc )
+++ #define WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " When: " << desc )
+++ #define AND_WHEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And when: " << desc )
+++ #define THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " Then: " << desc )
+++ #define AND_THEN( desc ) INTERNAL_CATCH_DYNAMIC_SECTION( " And: " << desc )
+++
+++#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE) // ^^ unprefixed, implemented | vv unprefixed, disabled
+++
+++ #define REQUIRE( ... ) (void)(0)
+++ #define REQUIRE_FALSE( ... ) (void)(0)
+++
+++ #define REQUIRE_THROWS( ... ) (void)(0)
+++ #define REQUIRE_THROWS_AS( expr, exceptionType ) (void)(0)
+++ #define REQUIRE_NOTHROW( ... ) (void)(0)
+++
+++ #define CHECK( ... ) (void)(0)
+++ #define CHECK_FALSE( ... ) (void)(0)
+++ #define CHECKED_IF( ... ) if (__VA_ARGS__)
+++ #define CHECKED_ELSE( ... ) if (!(__VA_ARGS__))
+++ #define CHECK_NOFAIL( ... ) (void)(0)
+++
+++ #define CHECK_THROWS( ... ) (void)(0)
+++ #define CHECK_THROWS_AS( expr, exceptionType ) (void)(0)
+++ #define CHECK_NOTHROW( ... ) (void)(0)
+++
+++ #define TEST_CASE( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), __VA_ARGS__)
+++ #define TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ))
+++ #define METHOD_AS_TEST_CASE( method, ... )
+++ #define REGISTER_TEST_CASE( Function, ... ) (void)(0)
+++ #define SECTION( ... )
+++ #define DYNAMIC_SECTION( ... )
+++ #define FAIL( ... ) (void)(0)
+++ #define FAIL_CHECK( ... ) (void)(0)
+++ #define SUCCEED( ... ) (void)(0)
+++ #define SKIP( ... ) (void)(0)
+++
+++ #define STATIC_REQUIRE( ... ) (void)(0)
+++ #define STATIC_REQUIRE_FALSE( ... ) (void)(0)
+++ #define STATIC_CHECK( ... ) (void)(0)
+++ #define STATIC_CHECK_FALSE( ... ) (void)(0)
+++
+++ // "BDD-style" convenience wrappers
+++ #define SCENARIO( ... ) INTERNAL_CATCH_TESTCASE_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ) )
+++ #define SCENARIO_METHOD( className, ... ) INTERNAL_CATCH_TESTCASE_METHOD_NO_REGISTRATION(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEST_ ), className )
+++
+++ #define GIVEN( desc )
+++ #define AND_GIVEN( desc )
+++ #define WHEN( desc )
+++ #define AND_WHEN( desc )
+++ #define THEN( desc )
+++ #define AND_THEN( desc )
+++
+++#endif // ^^ unprefixed, disabled
+++
+++// end of user facing macros
+++
+++#endif // CATCH_TEST_MACROS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
+++#define CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_PREPROCESSOR_HPP_INCLUDED
+++#define CATCH_PREPROCESSOR_HPP_INCLUDED
+++
+++
+++#if defined(__GNUC__)
+++// We need to silence "empty __VA_ARGS__ warning", and using just _Pragma does not work
+++#pragma GCC system_header
+++#endif
+++
+++
+++#define CATCH_RECURSION_LEVEL0(...) __VA_ARGS__
+++#define CATCH_RECURSION_LEVEL1(...) CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(CATCH_RECURSION_LEVEL0(__VA_ARGS__)))
+++#define CATCH_RECURSION_LEVEL2(...) CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(CATCH_RECURSION_LEVEL1(__VA_ARGS__)))
+++#define CATCH_RECURSION_LEVEL3(...) CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(CATCH_RECURSION_LEVEL2(__VA_ARGS__)))
+++#define CATCH_RECURSION_LEVEL4(...) CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(CATCH_RECURSION_LEVEL3(__VA_ARGS__)))
+++#define CATCH_RECURSION_LEVEL5(...) CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(CATCH_RECURSION_LEVEL4(__VA_ARGS__)))
+++
+++#ifdef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++#define INTERNAL_CATCH_EXPAND_VARGS(...) __VA_ARGS__
+++// MSVC needs more evaluations
+++#define CATCH_RECURSION_LEVEL6(...) CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(CATCH_RECURSION_LEVEL5(__VA_ARGS__)))
+++#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL6(CATCH_RECURSION_LEVEL6(__VA_ARGS__))
+++#else
+++#define CATCH_RECURSE(...) CATCH_RECURSION_LEVEL5(__VA_ARGS__)
+++#endif
+++
+++#define CATCH_REC_END(...)
+++#define CATCH_REC_OUT
+++
+++#define CATCH_EMPTY()
+++#define CATCH_DEFER(id) id CATCH_EMPTY()
+++
+++#define CATCH_REC_GET_END2() 0, CATCH_REC_END
+++#define CATCH_REC_GET_END1(...) CATCH_REC_GET_END2
+++#define CATCH_REC_GET_END(...) CATCH_REC_GET_END1
+++#define CATCH_REC_NEXT0(test, next, ...) next CATCH_REC_OUT
+++#define CATCH_REC_NEXT1(test, next) CATCH_DEFER ( CATCH_REC_NEXT0 ) ( test, next, 0)
+++#define CATCH_REC_NEXT(test, next) CATCH_REC_NEXT1(CATCH_REC_GET_END test, next)
+++
+++#define CATCH_REC_LIST0(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+++#define CATCH_REC_LIST1(f, x, peek, ...) , f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0) ) ( f, peek, __VA_ARGS__ )
+++#define CATCH_REC_LIST2(f, x, peek, ...) f(x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1) ) ( f, peek, __VA_ARGS__ )
+++
+++#define CATCH_REC_LIST0_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+++#define CATCH_REC_LIST1_UD(f, userdata, x, peek, ...) , f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST0_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+++#define CATCH_REC_LIST2_UD(f, userdata, x, peek, ...) f(userdata, x) CATCH_DEFER ( CATCH_REC_NEXT(peek, CATCH_REC_LIST1_UD) ) ( f, userdata, peek, __VA_ARGS__ )
+++
+++// Applies the function macro `f` to each of the remaining parameters, inserts commas between the results,
+++// and passes userdata as the first parameter to each invocation,
+++// e.g. CATCH_REC_LIST_UD(f, x, a, b, c) evaluates to f(x, a), f(x, b), f(x, c)
+++#define CATCH_REC_LIST_UD(f, userdata, ...) CATCH_RECURSE(CATCH_REC_LIST2_UD(f, userdata, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+++
+++#define CATCH_REC_LIST(f, ...) CATCH_RECURSE(CATCH_REC_LIST2(f, __VA_ARGS__, ()()(), ()()(), ()()(), 0))
+++
+++#define INTERNAL_CATCH_STRINGIZE(...) INTERNAL_CATCH_STRINGIZE2(__VA_ARGS__)
+++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++#define INTERNAL_CATCH_STRINGIZE2(...) #__VA_ARGS__
+++#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param))
+++#else
+++// MSVC is adding extra space and needs another indirection to expand INTERNAL_CATCH_NOINTERNAL_CATCH_DEF
+++#define INTERNAL_CATCH_STRINGIZE2(...) INTERNAL_CATCH_STRINGIZE3(__VA_ARGS__)
+++#define INTERNAL_CATCH_STRINGIZE3(...) #__VA_ARGS__
+++#define INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS(param) (INTERNAL_CATCH_STRINGIZE(INTERNAL_CATCH_REMOVE_PARENS(param)) + 1)
+++#endif
+++
+++#define INTERNAL_CATCH_MAKE_NAMESPACE2(...) ns_##__VA_ARGS__
+++#define INTERNAL_CATCH_MAKE_NAMESPACE(name) INTERNAL_CATCH_MAKE_NAMESPACE2(name)
+++
+++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>())
+++#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__))
+++#else
+++#define INTERNAL_CATCH_MAKE_TYPE_LIST2(...) INTERNAL_CATCH_EXPAND_VARGS(decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS_GEN(__VA_ARGS__)>()))
+++#define INTERNAL_CATCH_MAKE_TYPE_LIST(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_MAKE_TYPE_LIST2(INTERNAL_CATCH_REMOVE_PARENS(__VA_ARGS__)))
+++#endif
+++
+++#define INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(...)\
+++ CATCH_REC_LIST(INTERNAL_CATCH_MAKE_TYPE_LIST,__VA_ARGS__)
+++
+++#define INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_0) INTERNAL_CATCH_REMOVE_PARENS(_0)
+++#define INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_0, _1) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_1_ARG(_1)
+++#define INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_0, _1, _2) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_2_ARG(_1, _2)
+++#define INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_0, _1, _2, _3) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_3_ARG(_1, _2, _3)
+++#define INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_0, _1, _2, _3, _4) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_4_ARG(_1, _2, _3, _4)
+++#define INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_0, _1, _2, _3, _4, _5) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_5_ARG(_1, _2, _3, _4, _5)
+++#define INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_0, _1, _2, _3, _4, _5, _6) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_6_ARG(_1, _2, _3, _4, _5, _6)
+++#define INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_0, _1, _2, _3, _4, _5, _6, _7) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_7_ARG(_1, _2, _3, _4, _5, _6, _7)
+++#define INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_8_ARG(_1, _2, _3, _4, _5, _6, _7, _8)
+++#define INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_9_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9)
+++#define INTERNAL_CATCH_REMOVE_PARENS_11_ARG(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10) INTERNAL_CATCH_REMOVE_PARENS(_0), INTERNAL_CATCH_REMOVE_PARENS_10_ARG(_1, _2, _3, _4, _5, _6, _7, _8, _9, _10)
+++
+++#define INTERNAL_CATCH_VA_NARGS_IMPL(_0, _1, _2, _3, _4, _5, _6, _7, _8, _9, _10, N, ...) N
+++
+++#define INTERNAL_CATCH_TYPE_GEN\
+++ template<typename...> struct TypeList {};\
+++ template<typename...Ts>\
+++ constexpr auto get_wrapper() noexcept -> TypeList<Ts...> { return {}; }\
+++ template<template<typename...> class...> struct TemplateTypeList{};\
+++ template<template<typename...> class...Cs>\
+++ constexpr auto get_wrapper() noexcept -> TemplateTypeList<Cs...> { return {}; }\
+++ template<typename...>\
+++ struct append;\
+++ template<typename...>\
+++ struct rewrap;\
+++ template<template<typename...> class, typename...>\
+++ struct create;\
+++ template<template<typename...> class, typename>\
+++ struct convert;\
+++ \
+++ template<typename T> \
+++ struct append<T> { using type = T; };\
+++ template< template<typename...> class L1, typename...E1, template<typename...> class L2, typename...E2, typename...Rest>\
+++ struct append<L1<E1...>, L2<E2...>, Rest...> { using type = typename append<L1<E1...,E2...>, Rest...>::type; };\
+++ template< template<typename...> class L1, typename...E1, typename...Rest>\
+++ struct append<L1<E1...>, TypeList<mpl_::na>, Rest...> { using type = L1<E1...>; };\
+++ \
+++ template< template<typename...> class Container, template<typename...> class List, typename...elems>\
+++ struct rewrap<TemplateTypeList<Container>, List<elems...>> { using type = TypeList<Container<elems...>>; };\
+++ template< template<typename...> class Container, template<typename...> class List, class...Elems, typename...Elements>\
+++ struct rewrap<TemplateTypeList<Container>, List<Elems...>, Elements...> { using type = typename append<TypeList<Container<Elems...>>, typename rewrap<TemplateTypeList<Container>, Elements...>::type>::type; };\
+++ \
+++ template<template <typename...> class Final, template< typename...> class...Containers, typename...Types>\
+++ struct create<Final, TemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<TemplateTypeList<Containers>, Types...>::type...>::type; };\
+++ template<template <typename...> class Final, template <typename...> class List, typename...Ts>\
+++ struct convert<Final, List<Ts...>> { using type = typename append<Final<>,TypeList<Ts>...>::type; };
+++
+++#define INTERNAL_CATCH_NTTP_1(signature, ...)\
+++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)> struct Nttp{};\
+++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+++ constexpr auto get_wrapper() noexcept -> Nttp<__VA_ARGS__> { return {}; } \
+++ template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...> struct NttpTemplateTypeList{};\
+++ template<template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Cs>\
+++ constexpr auto get_wrapper() noexcept -> NttpTemplateTypeList<Cs...> { return {}; } \
+++ \
+++ template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+++ struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>> { using type = TypeList<Container<__VA_ARGS__>>; };\
+++ template< template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class Container, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class List, INTERNAL_CATCH_REMOVE_PARENS(signature), typename...Elements>\
+++ struct rewrap<NttpTemplateTypeList<Container>, List<__VA_ARGS__>, Elements...> { using type = typename append<TypeList<Container<__VA_ARGS__>>, typename rewrap<NttpTemplateTypeList<Container>, Elements...>::type>::type; };\
+++ template<template <typename...> class Final, template<INTERNAL_CATCH_REMOVE_PARENS(signature)> class...Containers, typename...Types>\
+++ struct create<Final, NttpTemplateTypeList<Containers...>, TypeList<Types...>> { using type = typename append<Final<>, typename rewrap<NttpTemplateTypeList<Containers>, Types...>::type...>::type; };
+++
+++#define INTERNAL_CATCH_DECLARE_SIG_TEST0(TestName)
+++#define INTERNAL_CATCH_DECLARE_SIG_TEST1(TestName, signature)\
+++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+++ static void TestName()
+++#define INTERNAL_CATCH_DECLARE_SIG_TEST_X(TestName, signature, ...)\
+++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+++ static void TestName()
+++
+++#define INTERNAL_CATCH_DEFINE_SIG_TEST0(TestName)
+++#define INTERNAL_CATCH_DEFINE_SIG_TEST1(TestName, signature)\
+++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+++ static void TestName()
+++#define INTERNAL_CATCH_DEFINE_SIG_TEST_X(TestName, signature,...)\
+++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+++ static void TestName()
+++
+++#define INTERNAL_CATCH_NTTP_REGISTER0(TestFunc, signature)\
+++ template<typename Type>\
+++ void reg_test(TypeList<Type>, Catch::NameAndTags nameAndTags)\
+++ {\
+++ Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<Type>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+++ }
+++
+++#define INTERNAL_CATCH_NTTP_REGISTER(TestFunc, signature, ...)\
+++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+++ void reg_test(Nttp<__VA_ARGS__>, Catch::NameAndTags nameAndTags)\
+++ {\
+++ Catch::AutoReg( Catch::makeTestInvoker(&TestFunc<__VA_ARGS__>), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), nameAndTags);\
+++ }
+++
+++#define INTERNAL_CATCH_NTTP_REGISTER_METHOD0(TestName, signature, ...)\
+++ template<typename Type>\
+++ void reg_test(TypeList<Type>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+++ {\
+++ Catch::AutoReg( Catch::makeTestInvoker(&TestName<Type>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+++ }
+++
+++#define INTERNAL_CATCH_NTTP_REGISTER_METHOD(TestName, signature, ...)\
+++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)>\
+++ void reg_test(Nttp<__VA_ARGS__>, Catch::StringRef className, Catch::NameAndTags nameAndTags)\
+++ {\
+++ Catch::AutoReg( Catch::makeTestInvoker(&TestName<__VA_ARGS__>::test), CATCH_INTERNAL_LINEINFO, className, nameAndTags);\
+++ }
+++
+++#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0(TestName, ClassName)
+++#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1(TestName, ClassName, signature)\
+++ template<typename TestType> \
+++ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<TestType> { \
+++ void test();\
+++ }
+++
+++#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X(TestName, ClassName, signature, ...)\
+++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+++ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName)<__VA_ARGS__> { \
+++ void test();\
+++ }
+++
+++#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0(TestName)
+++#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1(TestName, signature)\
+++ template<typename TestType> \
+++ void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<TestType>::test()
+++#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X(TestName, signature, ...)\
+++ template<INTERNAL_CATCH_REMOVE_PARENS(signature)> \
+++ void INTERNAL_CATCH_MAKE_NAMESPACE(TestName)::TestName<__VA_ARGS__>::test()
+++
+++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++#define INTERNAL_CATCH_NTTP_0
+++#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1(__VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_1( __VA_ARGS__),INTERNAL_CATCH_NTTP_1( __VA_ARGS__), INTERNAL_CATCH_NTTP_0)
+++#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__)
+++#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__)
+++#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__)
+++#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__)
+++#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__)
+++#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__)
+++#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__)
+++#else
+++#define INTERNAL_CATCH_NTTP_0(signature)
+++#define INTERNAL_CATCH_NTTP_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_1,INTERNAL_CATCH_NTTP_1, INTERNAL_CATCH_NTTP_0)( __VA_ARGS__))
+++#define INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD1, INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD0)(TestName, __VA_ARGS__))
+++#define INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X,INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD_X, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD1, INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD0)(TestName, ClassName, __VA_ARGS__))
+++#define INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD, INTERNAL_CATCH_NTTP_REGISTER_METHOD0, INTERNAL_CATCH_NTTP_REGISTER_METHOD0)(TestName, __VA_ARGS__))
+++#define INTERNAL_CATCH_NTTP_REG_GEN(TestFunc, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER, INTERNAL_CATCH_NTTP_REGISTER0, INTERNAL_CATCH_NTTP_REGISTER0)(TestFunc, __VA_ARGS__))
+++#define INTERNAL_CATCH_DEFINE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DEFINE_SIG_TEST1, INTERNAL_CATCH_DEFINE_SIG_TEST0)(TestName, __VA_ARGS__))
+++#define INTERNAL_CATCH_DECLARE_SIG_TEST(TestName, ...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL( "dummy", __VA_ARGS__, INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DEFINE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X,INTERNAL_CATCH_DECLARE_SIG_TEST_X, INTERNAL_CATCH_DECLARE_SIG_TEST1, INTERNAL_CATCH_DECLARE_SIG_TEST0)(TestName, __VA_ARGS__))
+++#define INTERNAL_CATCH_REMOVE_PARENS_GEN(...) INTERNAL_CATCH_EXPAND_VARGS(INTERNAL_CATCH_VA_NARGS_IMPL(__VA_ARGS__, INTERNAL_CATCH_REMOVE_PARENS_11_ARG,INTERNAL_CATCH_REMOVE_PARENS_10_ARG,INTERNAL_CATCH_REMOVE_PARENS_9_ARG,INTERNAL_CATCH_REMOVE_PARENS_8_ARG,INTERNAL_CATCH_REMOVE_PARENS_7_ARG,INTERNAL_CATCH_REMOVE_PARENS_6_ARG,INTERNAL_CATCH_REMOVE_PARENS_5_ARG,INTERNAL_CATCH_REMOVE_PARENS_4_ARG,INTERNAL_CATCH_REMOVE_PARENS_3_ARG,INTERNAL_CATCH_REMOVE_PARENS_2_ARG,INTERNAL_CATCH_REMOVE_PARENS_1_ARG)(__VA_ARGS__))
+++#endif
+++
+++#endif // CATCH_PREPROCESSOR_HPP_INCLUDED
+++
+++
+++// GCC 5 and older do not properly handle disabling unused-variable warning
+++// with a _Pragma. This means that we have to leak the suppression to the
+++// user code as well :-(
+++#if defined(__GNUC__) && !defined(__clang__) && __GNUC__ <= 5
+++#pragma GCC diagnostic ignored "-Wunused-variable"
+++#endif
+++
+++#if defined(CATCH_CONFIG_DISABLE)
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( TestName, TestFunc, Name, Tags, Signature, ... ) \
+++ INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
+++ namespace{ \
+++ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
+++ INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+++ } \
+++ } \
+++ INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+++
+++ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+++ INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ )
+++ #else
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(Name, Tags, ...) \
+++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+++ #endif
+++
+++ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+++ INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ )
+++ #else
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(Name, Tags, Signature, ...) \
+++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
+++ #endif
+++
+++ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+++ INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+++ #else
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION( ClassName, Name, Tags,... ) \
+++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+++ #endif
+++
+++ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+++ INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+++ #else
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION( ClassName, Name, Tags, Signature, ... ) \
+++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+++ #endif
+++#endif
+++
+++
+++ ///////////////////////////////////////////////////////////////////////////////
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_2(TestName, TestFunc, Name, Tags, Signature, ... )\
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+++ INTERNAL_CATCH_DECLARE_SIG_TEST(TestFunc, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+++ namespace {\
+++ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+++ INTERNAL_CATCH_TYPE_GEN\
+++ INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+++ INTERNAL_CATCH_NTTP_REG_GEN(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+++ template<typename...Types> \
+++ struct TestName{\
+++ TestName(){\
+++ size_t index = 0; \
+++ constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)}; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
+++ using expander = size_t[]; /* NOLINT(cppcoreguidelines-avoid-c-arrays,modernize-avoid-c-arrays,hicpp-avoid-c-arrays) */\
+++ (void)expander{(reg_test(Types{}, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
+++ }\
+++ };\
+++ static const int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+++ TestName<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+++ return 0;\
+++ }();\
+++ }\
+++ }\
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+++ INTERNAL_CATCH_DEFINE_SIG_TEST(TestFunc,INTERNAL_CATCH_REMOVE_PARENS(Signature))
+++
+++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+++ INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ )
+++#else
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE(Name, Tags, ...) \
+++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename TestType, __VA_ARGS__ ) )
+++#endif
+++
+++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+++ INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ )
+++#else
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG(Name, Tags, Signature, ...) \
+++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
+++#endif
+++
+++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(TestName, TestFuncName, Name, Tags, Signature, TmplTypes, TypesList) \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+++ template<typename TestType> static void TestFuncName(); \
+++ namespace {\
+++ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName) { \
+++ INTERNAL_CATCH_TYPE_GEN \
+++ INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature)) \
+++ template<typename... Types> \
+++ struct TestName { \
+++ void reg_tests() { \
+++ size_t index = 0; \
+++ using expander = size_t[]; \
+++ constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+++ constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+++ constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+++ (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFuncName<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + '<' + std::string(types_list[index % num_types]) + '>', Tags } ), index++)... };/* NOLINT */\
+++ } \
+++ }; \
+++ static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+++ using TestInit = typename create<TestName, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type; \
+++ TestInit t; \
+++ t.reg_tests(); \
+++ return 0; \
+++ }(); \
+++ } \
+++ } \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+++ template<typename TestType> \
+++ static void TestFuncName()
+++
+++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+++ INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename T,__VA_ARGS__)
+++#else
+++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE(Name, Tags, ...)\
+++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, typename T, __VA_ARGS__ ) )
+++#endif
+++
+++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+++ INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2(INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__)
+++#else
+++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG(Name, Tags, Signature, ...)\
+++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, Signature, __VA_ARGS__ ) )
+++#endif
+++
+++ #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2(TestName, TestFunc, Name, Tags, TmplList)\
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+++ template<typename TestType> static void TestFunc(); \
+++ namespace {\
+++ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){\
+++ INTERNAL_CATCH_TYPE_GEN\
+++ template<typename... Types> \
+++ struct TestName { \
+++ void reg_tests() { \
+++ size_t index = 0; \
+++ using expander = size_t[]; \
+++ (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestFunc<Types> ), CATCH_INTERNAL_LINEINFO, Catch::StringRef(), Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */\
+++ } \
+++ };\
+++ static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){ \
+++ using TestInit = typename convert<TestName, TmplList>::type; \
+++ TestInit t; \
+++ t.reg_tests(); \
+++ return 0; \
+++ }(); \
+++ }}\
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+++ template<typename TestType> \
+++ static void TestFunc()
+++
+++ #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(Name, Tags, TmplList) \
+++ INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), Name, Tags, TmplList )
+++
+++
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, Signature, ... ) \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ namespace {\
+++ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+++ INTERNAL_CATCH_TYPE_GEN\
+++ INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+++ INTERNAL_CATCH_DECLARE_SIG_TEST_METHOD(TestName, ClassName, INTERNAL_CATCH_REMOVE_PARENS(Signature));\
+++ INTERNAL_CATCH_NTTP_REG_METHOD_GEN(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+++ template<typename...Types> \
+++ struct TestNameClass{\
+++ TestNameClass(){\
+++ size_t index = 0; \
+++ constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, __VA_ARGS__)};\
+++ using expander = size_t[];\
+++ (void)expander{(reg_test(Types{}, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index]), Tags } ), index++)... };/* NOLINT */ \
+++ }\
+++ };\
+++ static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+++ TestNameClass<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(__VA_ARGS__)>();\
+++ return 0;\
+++ }();\
+++ }\
+++ }\
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+++ INTERNAL_CATCH_DEFINE_SIG_TEST_METHOD(TestName, INTERNAL_CATCH_REMOVE_PARENS(Signature))
+++
+++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+++ INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ )
+++#else
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( ClassName, Name, Tags,... ) \
+++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, typename T, __VA_ARGS__ ) )
+++#endif
+++
+++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+++ INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ )
+++#else
+++ #define INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... ) \
+++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_CLASS_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ) , ClassName, Name, Tags, Signature, __VA_ARGS__ ) )
+++#endif
+++
+++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2(TestNameClass, TestName, ClassName, Name, Tags, Signature, TmplTypes, TypesList)\
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_ZERO_VARIADIC_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ template<typename TestType> \
+++ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+++ void test();\
+++ };\
+++ namespace {\
+++ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestNameClass) {\
+++ INTERNAL_CATCH_TYPE_GEN \
+++ INTERNAL_CATCH_NTTP_GEN(INTERNAL_CATCH_REMOVE_PARENS(Signature))\
+++ template<typename...Types>\
+++ struct TestNameClass{\
+++ void reg_tests(){\
+++ std::size_t index = 0;\
+++ using expander = std::size_t[];\
+++ constexpr char const* tmpl_types[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TmplTypes))};\
+++ constexpr char const* types_list[] = {CATCH_REC_LIST(INTERNAL_CATCH_STRINGIZE_WITHOUT_PARENS, INTERNAL_CATCH_REMOVE_PARENS(TypesList))};\
+++ constexpr auto num_types = sizeof(types_list) / sizeof(types_list[0]);\
+++ (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName, Catch::NameAndTags{ Name " - " + std::string(tmpl_types[index / num_types]) + '<' + std::string(types_list[index % num_types]) + '>', Tags } ), index++)... };/* NOLINT */ \
+++ }\
+++ };\
+++ static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+++ using TestInit = typename create<TestNameClass, decltype(get_wrapper<INTERNAL_CATCH_REMOVE_PARENS(TmplTypes)>()), TypeList<INTERNAL_CATCH_MAKE_TYPE_LISTS_FROM_TYPES(INTERNAL_CATCH_REMOVE_PARENS(TypesList))>>::type;\
+++ TestInit t;\
+++ t.reg_tests();\
+++ return 0;\
+++ }(); \
+++ }\
+++ }\
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+++ template<typename TestType> \
+++ void TestName<TestType>::test()
+++
+++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+++ INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, typename T, __VA_ARGS__ )
+++#else
+++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( ClassName, Name, Tags, ... )\
+++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, typename T,__VA_ARGS__ ) )
+++#endif
+++
+++#ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+++ INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, Signature, __VA_ARGS__ )
+++#else
+++ #define INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( ClassName, Name, Tags, Signature, ... )\
+++ INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, Signature,__VA_ARGS__ ) )
+++#endif
+++
+++ #define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( TestNameClass, TestName, ClassName, Name, Tags, TmplList) \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_TEMPLATE_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_UNUSED_VARIABLE_WARNINGS \
+++ CATCH_INTERNAL_SUPPRESS_COMMA_WARNINGS \
+++ template<typename TestType> \
+++ struct TestName : INTERNAL_CATCH_REMOVE_PARENS(ClassName <TestType>) { \
+++ void test();\
+++ };\
+++ namespace {\
+++ namespace INTERNAL_CATCH_MAKE_NAMESPACE(TestName){ \
+++ INTERNAL_CATCH_TYPE_GEN\
+++ template<typename...Types>\
+++ struct TestNameClass{\
+++ void reg_tests(){\
+++ size_t index = 0;\
+++ using expander = size_t[];\
+++ (void)expander{(Catch::AutoReg( Catch::makeTestInvoker( &TestName<Types>::test ), CATCH_INTERNAL_LINEINFO, #ClassName##_catch_sr, Catch::NameAndTags{ Name " - " INTERNAL_CATCH_STRINGIZE(TmplList) " - " + std::to_string(index), Tags } ), index++)... };/* NOLINT */ \
+++ }\
+++ };\
+++ static int INTERNAL_CATCH_UNIQUE_NAME( globalRegistrar ) = [](){\
+++ using TestInit = typename convert<TestNameClass, TmplList>::type;\
+++ TestInit t;\
+++ t.reg_tests();\
+++ return 0;\
+++ }(); \
+++ }}\
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+++ template<typename TestType> \
+++ void TestName<TestType>::test()
+++
+++#define INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD(ClassName, Name, Tags, TmplList) \
+++ INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD_2( INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), INTERNAL_CATCH_UNIQUE_NAME( CATCH2_INTERNAL_TEMPLATE_TEST_ ), ClassName, Name, Tags, TmplList )
+++
+++
+++#endif // CATCH_TEMPLATE_TEST_REGISTRY_HPP_INCLUDED
+++
+++
+++#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+++
+++ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++ #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+++ #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+++ #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+++ #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+++ #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
+++ #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
+++ #else
+++ #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+++ #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+++ #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+++ #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+++ #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
+++ #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+++ #endif
+++
+++#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+++
+++ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++ #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+++ #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+++ #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+++ #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+++ #else
+++ #define CATCH_TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+++ #define CATCH_TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+++ #define CATCH_TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+++ #define CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+++ #endif
+++
+++ // When disabled, these can be shared between proper preprocessor and MSVC preprocessor
+++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+++ #define CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+++ #define CATCH_TEMPLATE_LIST_TEST_CASE( ... ) CATCH_TEMPLATE_TEST_CASE(__VA_ARGS__)
+++ #define CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+++
+++#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+++
+++ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++ #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ )
+++ #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ )
+++ #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+++ #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+++ #define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ )
+++ #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ )
+++ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ )
+++ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ )
+++ #define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE(__VA_ARGS__)
+++ #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ )
+++ #else
+++ #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE( __VA_ARGS__ ) )
+++ #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG( __VA_ARGS__ ) )
+++ #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+++ #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+++ #define TEMPLATE_PRODUCT_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE( __VA_ARGS__ ) )
+++ #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_SIG( __VA_ARGS__ ) )
+++ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+++ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, __VA_ARGS__ ) )
+++ #define TEMPLATE_LIST_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE( __VA_ARGS__ ) )
+++ #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_LIST_TEST_CASE_METHOD( className, __VA_ARGS__ ) )
+++ #endif
+++
+++#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+++
+++ #ifndef CATCH_CONFIG_TRADITIONAL_MSVC_PREPROCESSOR
+++ #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__)
+++ #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__)
+++ #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__)
+++ #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ )
+++ #else
+++ #define TEMPLATE_TEST_CASE( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_NO_REGISTRATION(__VA_ARGS__) )
+++ #define TEMPLATE_TEST_CASE_SIG( ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_SIG_NO_REGISTRATION(__VA_ARGS__) )
+++ #define TEMPLATE_TEST_CASE_METHOD( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_NO_REGISTRATION(className, __VA_ARGS__ ) )
+++ #define TEMPLATE_TEST_CASE_METHOD_SIG( className, ... ) INTERNAL_CATCH_EXPAND_VARGS( INTERNAL_CATCH_TEMPLATE_TEST_CASE_METHOD_SIG_NO_REGISTRATION(className, __VA_ARGS__ ) )
+++ #endif
+++
+++ // When disabled, these can be shared between proper preprocessor and MSVC preprocessor
+++ #define TEMPLATE_PRODUCT_TEST_CASE( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+++ #define TEMPLATE_PRODUCT_TEST_CASE_SIG( ... ) TEMPLATE_TEST_CASE( __VA_ARGS__ )
+++ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+++ #define TEMPLATE_PRODUCT_TEST_CASE_METHOD_SIG( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+++ #define TEMPLATE_LIST_TEST_CASE( ... ) TEMPLATE_TEST_CASE(__VA_ARGS__)
+++ #define TEMPLATE_LIST_TEST_CASE_METHOD( className, ... ) TEMPLATE_TEST_CASE_METHOD( className, __VA_ARGS__ )
+++
+++#endif // end of user facing macro declarations
+++
+++
+++#endif // CATCH_TEMPLATE_TEST_MACROS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_TEST_CASE_INFO_HPP_INCLUDED
+++#define CATCH_TEST_CASE_INFO_HPP_INCLUDED
+++
+++
+++
+++#include <cstdint>
+++#include <string>
+++#include <vector>
+++
+++#ifdef __clang__
+++#pragma clang diagnostic push
+++#pragma clang diagnostic ignored "-Wpadded"
+++#endif
+++
+++namespace Catch {
+++
+++ /**
+++ * A **view** of a tag string that provides case insensitive comparisons
+++ *
+++ * Note that in Catch2 internals, the square brackets around tags are
+++ * not a part of tag's representation, so e.g. "[cool-tag]" is represented
+++ * as "cool-tag" internally.
+++ */
+++ struct Tag {
+++ constexpr Tag(StringRef original_):
+++ original(original_)
+++ {}
+++ StringRef original;
+++
+++ friend bool operator< ( Tag const& lhs, Tag const& rhs );
+++ friend bool operator==( Tag const& lhs, Tag const& rhs );
+++ };
+++
+++ class ITestInvoker;
+++ struct NameAndTags;
+++
+++ enum class TestCaseProperties : uint8_t {
+++ None = 0,
+++ IsHidden = 1 << 1,
+++ ShouldFail = 1 << 2,
+++ MayFail = 1 << 3,
+++ Throws = 1 << 4,
+++ NonPortable = 1 << 5,
+++ Benchmark = 1 << 6
+++ };
+++
+++ /**
+++ * Various metadata about the test case.
+++ *
+++ * A test case is uniquely identified by its (class)name and tags
+++ * combination, with source location being ignored, and other properties
+++ * being determined from tags.
+++ *
+++ * Tags are kept sorted.
+++ */
+++ struct TestCaseInfo : Detail::NonCopyable {
+++
+++ TestCaseInfo(StringRef _className,
+++ NameAndTags const& _nameAndTags,
+++ SourceLineInfo const& _lineInfo);
+++
+++ bool isHidden() const;
+++ bool throws() const;
+++ bool okToFail() const;
+++ bool expectedToFail() const;
+++
+++ // Adds the tag(s) with test's filename (for the -# flag)
+++ void addFilenameTag();
+++
+++ //! Orders by name, classname and tags
+++ friend bool operator<( TestCaseInfo const& lhs,
+++ TestCaseInfo const& rhs );
+++
+++
+++ std::string tagsAsString() const;
+++
+++ std::string name;
+++ StringRef className;
+++ private:
+++ std::string backingTags;
+++ // Internally we copy tags to the backing storage and then add
+++ // refs to this storage to the tags vector.
+++ void internalAppendTag(StringRef tagString);
+++ public:
+++ std::vector<Tag> tags;
+++ SourceLineInfo lineInfo;
+++ TestCaseProperties properties = TestCaseProperties::None;
+++ };
+++
+++ /**
+++ * Wrapper over the test case information and the test case invoker
+++ *
+++ * Does not own either, and is specifically made to be cheap
+++ * to copy around.
+++ */
+++ class TestCaseHandle {
+++ TestCaseInfo* m_info;
+++ ITestInvoker* m_invoker;
+++ public:
+++ TestCaseHandle(TestCaseInfo* info, ITestInvoker* invoker) :
+++ m_info(info), m_invoker(invoker) {}
+++
+++ void invoke() const {
+++ m_invoker->invoke();
+++ }
+++
+++ TestCaseInfo const& getTestCaseInfo() const;
+++ };
+++
+++ Detail::unique_ptr<TestCaseInfo>
+++ makeTestCaseInfo( StringRef className,
+++ NameAndTags const& nameAndTags,
+++ SourceLineInfo const& lineInfo );
+++}
+++
+++#ifdef __clang__
+++#pragma clang diagnostic pop
+++#endif
+++
+++#endif // CATCH_TEST_CASE_INFO_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
+++#define CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
+++#define CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
+++
+++
+++#include <string>
+++#include <vector>
+++
+++namespace Catch {
+++ using exceptionTranslateFunction = std::string(*)();
+++
+++ class IExceptionTranslator;
+++ using ExceptionTranslators = std::vector<Detail::unique_ptr<IExceptionTranslator const>>;
+++
+++ class IExceptionTranslator {
+++ public:
+++ virtual ~IExceptionTranslator(); // = default
+++ virtual std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const = 0;
+++ };
+++
+++ class IExceptionTranslatorRegistry {
+++ public:
+++ virtual ~IExceptionTranslatorRegistry(); // = default
+++ virtual std::string translateActiveException() const = 0;
+++ };
+++
+++} // namespace Catch
+++
+++#endif // CATCH_INTERFACES_EXCEPTION_HPP_INCLUDED
+++
+++#include <exception>
+++
+++namespace Catch {
+++ namespace Detail {
+++ void registerTranslatorImpl(
+++ Detail::unique_ptr<IExceptionTranslator>&& translator );
+++ }
+++
+++ class ExceptionTranslatorRegistrar {
+++ template<typename T>
+++ class ExceptionTranslator : public IExceptionTranslator {
+++ public:
+++
+++ ExceptionTranslator( std::string(*translateFunction)( T const& ) )
+++ : m_translateFunction( translateFunction )
+++ {}
+++
+++ std::string translate( ExceptionTranslators::const_iterator it, ExceptionTranslators::const_iterator itEnd ) const override {
+++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+++ try {
+++ if( it == itEnd )
+++ std::rethrow_exception(std::current_exception());
+++ else
+++ return (*it)->translate( it+1, itEnd );
+++ }
+++ catch( T const& ex ) {
+++ return m_translateFunction( ex );
+++ }
+++#else
+++ return "You should never get here!";
+++#endif
+++ }
+++
+++ protected:
+++ std::string(*m_translateFunction)( T const& );
+++ };
+++
+++ public:
+++ template<typename T>
+++ ExceptionTranslatorRegistrar( std::string(*translateFunction)( T const& ) ) {
+++ Detail::registerTranslatorImpl(
+++ Detail::make_unique<ExceptionTranslator<T>>(
+++ translateFunction ) );
+++ }
+++ };
+++
+++} // namespace Catch
+++
+++///////////////////////////////////////////////////////////////////////////////
+++#define INTERNAL_CATCH_TRANSLATE_EXCEPTION2( translatorName, signature ) \
+++ static std::string translatorName( signature ); \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+++ namespace{ Catch::ExceptionTranslatorRegistrar INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionRegistrar )( &translatorName ); } \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION \
+++ static std::string translatorName( signature )
+++
+++#define INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION2( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+++
+++#if defined(CATCH_CONFIG_DISABLE)
+++ #define INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( translatorName, signature) \
+++ static std::string translatorName( signature )
+++#endif
+++
+++
+++// This macro is always prefixed
+++#if !defined(CATCH_CONFIG_DISABLE)
+++#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION( signature )
+++#else
+++#define CATCH_TRANSLATE_EXCEPTION( signature ) INTERNAL_CATCH_TRANSLATE_EXCEPTION_NO_REG( INTERNAL_CATCH_UNIQUE_NAME( catch_internal_ExceptionTranslator ), signature )
+++#endif
+++
+++
+++#endif // CATCH_TRANSLATE_EXCEPTION_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_VERSION_HPP_INCLUDED
+++#define CATCH_VERSION_HPP_INCLUDED
+++
+++#include <iosfwd>
+++
+++namespace Catch {
+++
+++ // Versioning information
+++ struct Version {
+++ Version( Version const& ) = delete;
+++ Version& operator=( Version const& ) = delete;
+++ Version( unsigned int _majorVersion,
+++ unsigned int _minorVersion,
+++ unsigned int _patchNumber,
+++ char const * const _branchName,
+++ unsigned int _buildNumber );
+++
+++ unsigned int const majorVersion;
+++ unsigned int const minorVersion;
+++ unsigned int const patchNumber;
+++
+++ // buildNumber is only used if branchName is not null
+++ char const * const branchName;
+++ unsigned int const buildNumber;
+++
+++ friend std::ostream& operator << ( std::ostream& os, Version const& version );
+++ };
+++
+++ Version const& libraryVersion();
+++}
+++
+++#endif // CATCH_VERSION_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_VERSION_MACROS_HPP_INCLUDED
+++#define CATCH_VERSION_MACROS_HPP_INCLUDED
+++
+++#define CATCH_VERSION_MAJOR 3
+++#define CATCH_VERSION_MINOR 6
+++#define CATCH_VERSION_PATCH 0
+++
+++#endif // CATCH_VERSION_MACROS_HPP_INCLUDED
+++
+++
+++/** \file
+++ * This is a convenience header for Catch2's Generator support. It includes
+++ * **all** of Catch2 headers related to generators.
+++ *
+++ * Generally the Catch2 users should use specific includes they need,
+++ * but this header can be used instead for ease-of-experimentation, or
+++ * just plain convenience, at the cost of (significantly) increased
+++ * compilation times.
+++ *
+++ * When a new header is added to either the `generators` folder,
+++ * or to the corresponding internal subfolder, it should be added here.
+++ */
+++
+++#ifndef CATCH_GENERATORS_ALL_HPP_INCLUDED
+++#define CATCH_GENERATORS_ALL_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
+++#define CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
+++
+++#include <exception>
+++
+++namespace Catch {
+++
+++ // Exception type to be thrown when a Generator runs into an error,
+++ // e.g. it cannot initialize the first return value based on
+++ // runtime information
+++ class GeneratorException : public std::exception {
+++ const char* const m_msg = "";
+++
+++ public:
+++ GeneratorException(const char* msg):
+++ m_msg(msg)
+++ {}
+++
+++ const char* what() const noexcept override final;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_GENERATOR_EXCEPTION_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_GENERATORS_HPP_INCLUDED
+++#define CATCH_GENERATORS_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
+++#define CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
+++
+++
+++#include <string>
+++
+++namespace Catch {
+++
+++ namespace Generators {
+++ class GeneratorUntypedBase {
+++ // Caches result from `toStringImpl`, assume that when it is an
+++ // empty string, the cache is invalidated.
+++ mutable std::string m_stringReprCache;
+++
+++ // Counts based on `next` returning true
+++ std::size_t m_currentElementIndex = 0;
+++
+++ /**
+++ * Attempts to move the generator to the next element
+++ *
+++ * Returns true iff the move succeeded (and a valid element
+++ * can be retrieved).
+++ */
+++ virtual bool next() = 0;
+++
+++ //! Customization point for `currentElementAsString`
+++ virtual std::string stringifyImpl() const = 0;
+++
+++ public:
+++ GeneratorUntypedBase() = default;
+++ // Generation of copy ops is deprecated (and Clang will complain)
+++ // if there is a user destructor defined
+++ GeneratorUntypedBase(GeneratorUntypedBase const&) = default;
+++ GeneratorUntypedBase& operator=(GeneratorUntypedBase const&) = default;
+++
+++ virtual ~GeneratorUntypedBase(); // = default;
+++
+++ /**
+++ * Attempts to move the generator to the next element
+++ *
+++ * Serves as a non-virtual interface to `next`, so that the
+++ * top level interface can provide sanity checking and shared
+++ * features.
+++ *
+++ * As with `next`, returns true iff the move succeeded and
+++ * the generator has new valid element to provide.
+++ */
+++ bool countedNext();
+++
+++ std::size_t currentElementIndex() const { return m_currentElementIndex; }
+++
+++ /**
+++ * Returns generator's current element as user-friendly string.
+++ *
+++ * By default returns string equivalent to calling
+++ * `Catch::Detail::stringify` on the current element, but generators
+++ * can customize their implementation as needed.
+++ *
+++ * Not thread-safe due to internal caching.
+++ *
+++ * The returned ref is valid only until the generator instance
+++ * is destructed, or it moves onto the next element, whichever
+++ * comes first.
+++ */
+++ StringRef currentElementAsString() const;
+++ };
+++ using GeneratorBasePtr = Catch::Detail::unique_ptr<GeneratorUntypedBase>;
+++
+++ } // namespace Generators
+++
+++ class IGeneratorTracker {
+++ public:
+++ virtual ~IGeneratorTracker(); // = default;
+++ virtual auto hasGenerator() const -> bool = 0;
+++ virtual auto getGenerator() const -> Generators::GeneratorBasePtr const& = 0;
+++ virtual void setGenerator( Generators::GeneratorBasePtr&& generator ) = 0;
+++ };
+++
+++} // namespace Catch
+++
+++#endif // CATCH_INTERFACES_GENERATORTRACKER_HPP_INCLUDED
+++
+++#include <vector>
+++#include <tuple>
+++
+++namespace Catch {
+++
+++namespace Generators {
+++
+++namespace Detail {
+++
+++ //! Throws GeneratorException with the provided message
+++ [[noreturn]]
+++ void throw_generator_exception(char const * msg);
+++
+++} // end namespace detail
+++
+++ template<typename T>
+++ class IGenerator : public GeneratorUntypedBase {
+++ std::string stringifyImpl() const override {
+++ return ::Catch::Detail::stringify( get() );
+++ }
+++
+++ public:
+++ // Returns the current element of the generator
+++ //
+++ // \Precondition The generator is either freshly constructed,
+++ // or the last call to `next()` returned true
+++ virtual T const& get() const = 0;
+++ using type = T;
+++ };
+++
+++ template <typename T>
+++ using GeneratorPtr = Catch::Detail::unique_ptr<IGenerator<T>>;
+++
+++ template <typename T>
+++ class GeneratorWrapper final {
+++ GeneratorPtr<T> m_generator;
+++ public:
+++ //! Takes ownership of the passed pointer.
+++ GeneratorWrapper(IGenerator<T>* generator):
+++ m_generator(generator) {}
+++ GeneratorWrapper(GeneratorPtr<T> generator):
+++ m_generator(CATCH_MOVE(generator)) {}
+++
+++ T const& get() const {
+++ return m_generator->get();
+++ }
+++ bool next() {
+++ return m_generator->countedNext();
+++ }
+++ };
+++
+++
+++ template<typename T>
+++ class SingleValueGenerator final : public IGenerator<T> {
+++ T m_value;
+++ public:
+++ SingleValueGenerator(T const& value) :
+++ m_value(value)
+++ {}
+++ SingleValueGenerator(T&& value):
+++ m_value(CATCH_MOVE(value))
+++ {}
+++
+++ T const& get() const override {
+++ return m_value;
+++ }
+++ bool next() override {
+++ return false;
+++ }
+++ };
+++
+++ template<typename T>
+++ class FixedValuesGenerator final : public IGenerator<T> {
+++ static_assert(!std::is_same<T, bool>::value,
+++ "FixedValuesGenerator does not support bools because of std::vector<bool>"
+++ "specialization, use SingleValue Generator instead.");
+++ std::vector<T> m_values;
+++ size_t m_idx = 0;
+++ public:
+++ FixedValuesGenerator( std::initializer_list<T> values ) : m_values( values ) {}
+++
+++ T const& get() const override {
+++ return m_values[m_idx];
+++ }
+++ bool next() override {
+++ ++m_idx;
+++ return m_idx < m_values.size();
+++ }
+++ };
+++
+++ template <typename T, typename DecayedT = std::decay_t<T>>
+++ GeneratorWrapper<DecayedT> value( T&& value ) {
+++ return GeneratorWrapper<DecayedT>(
+++ Catch::Detail::make_unique<SingleValueGenerator<DecayedT>>(
+++ CATCH_FORWARD( value ) ) );
+++ }
+++ template <typename T>
+++ GeneratorWrapper<T> values(std::initializer_list<T> values) {
+++ return GeneratorWrapper<T>(Catch::Detail::make_unique<FixedValuesGenerator<T>>(values));
+++ }
+++
+++ template<typename T>
+++ class Generators : public IGenerator<T> {
+++ std::vector<GeneratorWrapper<T>> m_generators;
+++ size_t m_current = 0;
+++
+++ void add_generator( GeneratorWrapper<T>&& generator ) {
+++ m_generators.emplace_back( CATCH_MOVE( generator ) );
+++ }
+++ void add_generator( T const& val ) {
+++ m_generators.emplace_back( value( val ) );
+++ }
+++ void add_generator( T&& val ) {
+++ m_generators.emplace_back( value( CATCH_MOVE( val ) ) );
+++ }
+++ template <typename U>
+++ std::enable_if_t<!std::is_same<std::decay_t<U>, T>::value>
+++ add_generator( U&& val ) {
+++ add_generator( T( CATCH_FORWARD( val ) ) );
+++ }
+++
+++ template <typename U> void add_generators( U&& valueOrGenerator ) {
+++ add_generator( CATCH_FORWARD( valueOrGenerator ) );
+++ }
+++
+++ template <typename U, typename... Gs>
+++ void add_generators( U&& valueOrGenerator, Gs&&... moreGenerators ) {
+++ add_generator( CATCH_FORWARD( valueOrGenerator ) );
+++ add_generators( CATCH_FORWARD( moreGenerators )... );
+++ }
+++
+++ public:
+++ template <typename... Gs>
+++ Generators(Gs &&... moreGenerators) {
+++ m_generators.reserve(sizeof...(Gs));
+++ add_generators(CATCH_FORWARD(moreGenerators)...);
+++ }
+++
+++ T const& get() const override {
+++ return m_generators[m_current].get();
+++ }
+++
+++ bool next() override {
+++ if (m_current >= m_generators.size()) {
+++ return false;
+++ }
+++ const bool current_status = m_generators[m_current].next();
+++ if (!current_status) {
+++ ++m_current;
+++ }
+++ return m_current < m_generators.size();
+++ }
+++ };
+++
+++
+++ template <typename... Ts>
+++ GeneratorWrapper<std::tuple<std::decay_t<Ts>...>>
+++ table( std::initializer_list<std::tuple<std::decay_t<Ts>...>> tuples ) {
+++ return values<std::tuple<Ts...>>( tuples );
+++ }
+++
+++ // Tag type to signal that a generator sequence should convert arguments to a specific type
+++ template <typename T>
+++ struct as {};
+++
+++ template<typename T, typename... Gs>
+++ auto makeGenerators( GeneratorWrapper<T>&& generator, Gs &&... moreGenerators ) -> Generators<T> {
+++ return Generators<T>(CATCH_MOVE(generator), CATCH_FORWARD(moreGenerators)...);
+++ }
+++ template<typename T>
+++ auto makeGenerators( GeneratorWrapper<T>&& generator ) -> Generators<T> {
+++ return Generators<T>(CATCH_MOVE(generator));
+++ }
+++ template<typename T, typename... Gs>
+++ auto makeGenerators( T&& val, Gs &&... moreGenerators ) -> Generators<std::decay_t<T>> {
+++ return makeGenerators( value( CATCH_FORWARD( val ) ), CATCH_FORWARD( moreGenerators )... );
+++ }
+++ template<typename T, typename U, typename... Gs>
+++ auto makeGenerators( as<T>, U&& val, Gs &&... moreGenerators ) -> Generators<T> {
+++ return makeGenerators( value( T( CATCH_FORWARD( val ) ) ), CATCH_FORWARD( moreGenerators )... );
+++ }
+++
+++ IGeneratorTracker* acquireGeneratorTracker( StringRef generatorName,
+++ SourceLineInfo const& lineInfo );
+++ IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
+++ SourceLineInfo lineInfo,
+++ GeneratorBasePtr&& generator );
+++
+++ template<typename L>
+++ auto generate( StringRef generatorName, SourceLineInfo const& lineInfo, L const& generatorExpression ) -> typename decltype(generatorExpression())::type {
+++ using UnderlyingType = typename decltype(generatorExpression())::type;
+++
+++ IGeneratorTracker* tracker = acquireGeneratorTracker( generatorName, lineInfo );
+++ // Creation of tracker is delayed after generator creation, so
+++ // that constructing generator can fail without breaking everything.
+++ if (!tracker) {
+++ tracker = createGeneratorTracker(
+++ generatorName,
+++ lineInfo,
+++ Catch::Detail::make_unique<Generators<UnderlyingType>>(
+++ generatorExpression() ) );
+++ }
+++
+++ auto const& generator = static_cast<IGenerator<UnderlyingType> const&>( *tracker->getGenerator() );
+++ return generator.get();
+++ }
+++
+++} // namespace Generators
+++} // namespace Catch
+++
+++#define CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL( ... ) #__VA_ARGS__##_catch_sr
+++#define CATCH_INTERNAL_GENERATOR_STRINGIZE(...) CATCH_INTERNAL_GENERATOR_STRINGIZE_IMPL(__VA_ARGS__)
+++
+++#define GENERATE( ... ) \
+++ Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+++ CATCH_INTERNAL_LINEINFO, \
+++ [ ]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+++#define GENERATE_COPY( ... ) \
+++ Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+++ CATCH_INTERNAL_LINEINFO, \
+++ [=]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+++#define GENERATE_REF( ... ) \
+++ Catch::Generators::generate( CATCH_INTERNAL_GENERATOR_STRINGIZE(INTERNAL_CATCH_UNIQUE_NAME(generator)), \
+++ CATCH_INTERNAL_LINEINFO, \
+++ [&]{ using namespace Catch::Generators; return makeGenerators( __VA_ARGS__ ); } ) //NOLINT(google-build-using-namespace)
+++
+++#endif // CATCH_GENERATORS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
+++#define CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
+++
+++
+++#include <cassert>
+++
+++namespace Catch {
+++namespace Generators {
+++
+++ template <typename T>
+++ class TakeGenerator final : public IGenerator<T> {
+++ GeneratorWrapper<T> m_generator;
+++ size_t m_returned = 0;
+++ size_t m_target;
+++ public:
+++ TakeGenerator(size_t target, GeneratorWrapper<T>&& generator):
+++ m_generator(CATCH_MOVE(generator)),
+++ m_target(target)
+++ {
+++ assert(target != 0 && "Empty generators are not allowed");
+++ }
+++ T const& get() const override {
+++ return m_generator.get();
+++ }
+++ bool next() override {
+++ ++m_returned;
+++ if (m_returned >= m_target) {
+++ return false;
+++ }
+++
+++ const auto success = m_generator.next();
+++ // If the underlying generator does not contain enough values
+++ // then we cut short as well
+++ if (!success) {
+++ m_returned = m_target;
+++ }
+++ return success;
+++ }
+++ };
+++
+++ template <typename T>
+++ GeneratorWrapper<T> take(size_t target, GeneratorWrapper<T>&& generator) {
+++ return GeneratorWrapper<T>(Catch::Detail::make_unique<TakeGenerator<T>>(target, CATCH_MOVE(generator)));
+++ }
+++
+++
+++ template <typename T, typename Predicate>
+++ class FilterGenerator final : public IGenerator<T> {
+++ GeneratorWrapper<T> m_generator;
+++ Predicate m_predicate;
+++ public:
+++ template <typename P = Predicate>
+++ FilterGenerator(P&& pred, GeneratorWrapper<T>&& generator):
+++ m_generator(CATCH_MOVE(generator)),
+++ m_predicate(CATCH_FORWARD(pred))
+++ {
+++ if (!m_predicate(m_generator.get())) {
+++ // It might happen that there are no values that pass the
+++ // filter. In that case we throw an exception.
+++ auto has_initial_value = next();
+++ if (!has_initial_value) {
+++ Detail::throw_generator_exception("No valid value found in filtered generator");
+++ }
+++ }
+++ }
+++
+++ T const& get() const override {
+++ return m_generator.get();
+++ }
+++
+++ bool next() override {
+++ bool success = m_generator.next();
+++ if (!success) {
+++ return false;
+++ }
+++ while (!m_predicate(m_generator.get()) && (success = m_generator.next()) == true);
+++ return success;
+++ }
+++ };
+++
+++
+++ template <typename T, typename Predicate>
+++ GeneratorWrapper<T> filter(Predicate&& pred, GeneratorWrapper<T>&& generator) {
+++ return GeneratorWrapper<T>(Catch::Detail::make_unique<FilterGenerator<T, Predicate>>(CATCH_FORWARD(pred), CATCH_MOVE(generator)));
+++ }
+++
+++ template <typename T>
+++ class RepeatGenerator final : public IGenerator<T> {
+++ static_assert(!std::is_same<T, bool>::value,
+++ "RepeatGenerator currently does not support bools"
+++ "because of std::vector<bool> specialization");
+++ GeneratorWrapper<T> m_generator;
+++ mutable std::vector<T> m_returned;
+++ size_t m_target_repeats;
+++ size_t m_current_repeat = 0;
+++ size_t m_repeat_index = 0;
+++ public:
+++ RepeatGenerator(size_t repeats, GeneratorWrapper<T>&& generator):
+++ m_generator(CATCH_MOVE(generator)),
+++ m_target_repeats(repeats)
+++ {
+++ assert(m_target_repeats > 0 && "Repeat generator must repeat at least once");
+++ }
+++
+++ T const& get() const override {
+++ if (m_current_repeat == 0) {
+++ m_returned.push_back(m_generator.get());
+++ return m_returned.back();
+++ }
+++ return m_returned[m_repeat_index];
+++ }
+++
+++ bool next() override {
+++ // There are 2 basic cases:
+++ // 1) We are still reading the generator
+++ // 2) We are reading our own cache
+++
+++ // In the first case, we need to poke the underlying generator.
+++ // If it happily moves, we are left in that state, otherwise it is time to start reading from our cache
+++ if (m_current_repeat == 0) {
+++ const auto success = m_generator.next();
+++ if (!success) {
+++ ++m_current_repeat;
+++ }
+++ return m_current_repeat < m_target_repeats;
+++ }
+++
+++ // In the second case, we need to move indices forward and check that we haven't run up against the end
+++ ++m_repeat_index;
+++ if (m_repeat_index == m_returned.size()) {
+++ m_repeat_index = 0;
+++ ++m_current_repeat;
+++ }
+++ return m_current_repeat < m_target_repeats;
+++ }
+++ };
+++
+++ template <typename T>
+++ GeneratorWrapper<T> repeat(size_t repeats, GeneratorWrapper<T>&& generator) {
+++ return GeneratorWrapper<T>(Catch::Detail::make_unique<RepeatGenerator<T>>(repeats, CATCH_MOVE(generator)));
+++ }
+++
+++ template <typename T, typename U, typename Func>
+++ class MapGenerator final : public IGenerator<T> {
+++ // TBD: provide static assert for mapping function, for friendly error message
+++ GeneratorWrapper<U> m_generator;
+++ Func m_function;
+++ // To avoid returning dangling reference, we have to save the values
+++ T m_cache;
+++ public:
+++ template <typename F2 = Func>
+++ MapGenerator(F2&& function, GeneratorWrapper<U>&& generator) :
+++ m_generator(CATCH_MOVE(generator)),
+++ m_function(CATCH_FORWARD(function)),
+++ m_cache(m_function(m_generator.get()))
+++ {}
+++
+++ T const& get() const override {
+++ return m_cache;
+++ }
+++ bool next() override {
+++ const auto success = m_generator.next();
+++ if (success) {
+++ m_cache = m_function(m_generator.get());
+++ }
+++ return success;
+++ }
+++ };
+++
+++ template <typename Func, typename U, typename T = FunctionReturnType<Func, U>>
+++ GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+++ return GeneratorWrapper<T>(
+++ Catch::Detail::make_unique<MapGenerator<T, U, Func>>(CATCH_FORWARD(function), CATCH_MOVE(generator))
+++ );
+++ }
+++
+++ template <typename T, typename U, typename Func>
+++ GeneratorWrapper<T> map(Func&& function, GeneratorWrapper<U>&& generator) {
+++ return GeneratorWrapper<T>(
+++ Catch::Detail::make_unique<MapGenerator<T, U, Func>>(CATCH_FORWARD(function), CATCH_MOVE(generator))
+++ );
+++ }
+++
+++ template <typename T>
+++ class ChunkGenerator final : public IGenerator<std::vector<T>> {
+++ std::vector<T> m_chunk;
+++ size_t m_chunk_size;
+++ GeneratorWrapper<T> m_generator;
+++ bool m_used_up = false;
+++ public:
+++ ChunkGenerator(size_t size, GeneratorWrapper<T> generator) :
+++ m_chunk_size(size), m_generator(CATCH_MOVE(generator))
+++ {
+++ m_chunk.reserve(m_chunk_size);
+++ if (m_chunk_size != 0) {
+++ m_chunk.push_back(m_generator.get());
+++ for (size_t i = 1; i < m_chunk_size; ++i) {
+++ if (!m_generator.next()) {
+++ Detail::throw_generator_exception("Not enough values to initialize the first chunk");
+++ }
+++ m_chunk.push_back(m_generator.get());
+++ }
+++ }
+++ }
+++ std::vector<T> const& get() const override {
+++ return m_chunk;
+++ }
+++ bool next() override {
+++ m_chunk.clear();
+++ for (size_t idx = 0; idx < m_chunk_size; ++idx) {
+++ if (!m_generator.next()) {
+++ return false;
+++ }
+++ m_chunk.push_back(m_generator.get());
+++ }
+++ return true;
+++ }
+++ };
+++
+++ template <typename T>
+++ GeneratorWrapper<std::vector<T>> chunk(size_t size, GeneratorWrapper<T>&& generator) {
+++ return GeneratorWrapper<std::vector<T>>(
+++ Catch::Detail::make_unique<ChunkGenerator<T>>(size, CATCH_MOVE(generator))
+++ );
+++ }
+++
+++} // namespace Generators
+++} // namespace Catch
+++
+++
+++#endif // CATCH_GENERATORS_ADAPTERS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_GENERATORS_RANDOM_HPP_INCLUDED
+++#define CATCH_GENERATORS_RANDOM_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
+++#define CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
+++
+++#include <cstdint>
+++
+++namespace Catch {
+++
+++ // This is a simple implementation of C++11 Uniform Random Number
+++ // Generator. It does not provide all operators, because Catch2
+++ // does not use it, but it should behave as expected inside stdlib's
+++ // distributions.
+++ // The implementation is based on the PCG family (http://pcg-random.org)
+++ class SimplePcg32 {
+++ using state_type = std::uint64_t;
+++ public:
+++ using result_type = std::uint32_t;
+++ static constexpr result_type (min)() {
+++ return 0;
+++ }
+++ static constexpr result_type (max)() {
+++ return static_cast<result_type>(-1);
+++ }
+++
+++ // Provide some default initial state for the default constructor
+++ SimplePcg32():SimplePcg32(0xed743cc4U) {}
+++
+++ explicit SimplePcg32(result_type seed_);
+++
+++ void seed(result_type seed_);
+++ void discard(uint64_t skip);
+++
+++ result_type operator()();
+++
+++ private:
+++ friend bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+++ friend bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs);
+++
+++ // In theory we also need operator<< and operator>>
+++ // In practice we do not use them, so we will skip them for now
+++
+++
+++ std::uint64_t m_state;
+++ // This part of the state determines which "stream" of the numbers
+++ // is chosen -- we take it as a constant for Catch2, so we only
+++ // need to deal with seeding the main state.
+++ // Picked by reading 8 bytes from `/dev/random` :-)
+++ static const std::uint64_t s_inc = (0x13ed0cc53f939476ULL << 1ULL) | 1ULL;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_RANDOM_NUMBER_GENERATOR_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
+++#define CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
+++
+++
+++
+++
+++#ifndef CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
+++#define CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
+++
+++#include <climits>
+++#include <cstddef>
+++#include <cstdint>
+++#include <type_traits>
+++
+++// Note: We use the usual enable-disable-autodetect dance here even though
+++// we do not support these in CMake configuration options (yet?).
+++// It is highly unlikely that we will need to make these actually
+++// user-configurable, but this will make it simpler if weend up needing
+++// it, and it provides an escape hatch to the users who need it.
+++#if defined( __SIZEOF_INT128__ )
+++# define CATCH_CONFIG_INTERNAL_UINT128
+++// Unlike GCC, MSVC does not polyfill umul as mulh + mul pair on ARM machines.
+++// Currently we do not bother doing this ourselves, but we could if it became
+++// important for perf.
+++#elif defined( _MSC_VER ) && defined( _M_X64 )
+++# define CATCH_CONFIG_INTERNAL_MSVC_UMUL128
+++#endif
+++
+++#if defined( CATCH_CONFIG_INTERNAL_UINT128 ) && \
+++ !defined( CATCH_CONFIG_NO_UINT128 ) && \
+++ !defined( CATCH_CONFIG_UINT128 )
+++#define CATCH_CONFIG_UINT128
+++#endif
+++
+++#if defined( CATCH_CONFIG_INTERNAL_MSVC_UMUL128 ) && \
+++ !defined( CATCH_CONFIG_NO_MSVC_UMUL128 ) && \
+++ !defined( CATCH_CONFIG_MSVC_UMUL128 )
+++# define CATCH_CONFIG_MSVC_UMUL128
+++# include <intrin.h>
+++#endif
+++
+++
+++namespace Catch {
+++ namespace Detail {
+++
+++ template <std::size_t>
+++ struct SizedUnsignedType;
+++#define SizedUnsignedTypeHelper( TYPE ) \
+++ template <> \
+++ struct SizedUnsignedType<sizeof( TYPE )> { \
+++ using type = TYPE; \
+++ }
+++
+++ SizedUnsignedTypeHelper( std::uint8_t );
+++ SizedUnsignedTypeHelper( std::uint16_t );
+++ SizedUnsignedTypeHelper( std::uint32_t );
+++ SizedUnsignedTypeHelper( std::uint64_t );
+++#undef SizedUnsignedTypeHelper
+++
+++ template <std::size_t sz>
+++ using SizedUnsignedType_t = typename SizedUnsignedType<sz>::type;
+++
+++ template <typename T>
+++ using DoubleWidthUnsignedType_t = SizedUnsignedType_t<2 * sizeof( T )>;
+++
+++ template <typename T>
+++ struct ExtendedMultResult {
+++ T upper;
+++ T lower;
+++ bool operator==( ExtendedMultResult const& rhs ) const {
+++ return upper == rhs.upper && lower == rhs.lower;
+++ }
+++ };
+++
+++ /**
+++ * Returns 128 bit result of lhs * rhs using portable C++ code
+++ *
+++ * This implementation is almost twice as fast as naive long multiplication,
+++ * and unlike intrinsic-based approach, it supports constexpr evaluation.
+++ */
+++ constexpr ExtendedMultResult<std::uint64_t>
+++ extendedMultPortable(std::uint64_t lhs, std::uint64_t rhs) {
+++#define CarryBits( x ) ( x >> 32 )
+++#define Digits( x ) ( x & 0xFF'FF'FF'FF )
+++ std::uint64_t lhs_low = Digits( lhs );
+++ std::uint64_t rhs_low = Digits( rhs );
+++ std::uint64_t low_low = ( lhs_low * rhs_low );
+++ std::uint64_t high_high = CarryBits( lhs ) * CarryBits( rhs );
+++
+++ // We add in carry bits from low-low already
+++ std::uint64_t high_low =
+++ ( CarryBits( lhs ) * rhs_low ) + CarryBits( low_low );
+++ // Note that we can add only low bits from high_low, to avoid
+++ // overflow with large inputs
+++ std::uint64_t low_high =
+++ ( lhs_low * CarryBits( rhs ) ) + Digits( high_low );
+++
+++ return { high_high + CarryBits( high_low ) + CarryBits( low_high ),
+++ ( low_high << 32 ) | Digits( low_low ) };
+++#undef CarryBits
+++#undef Digits
+++ }
+++
+++ //! Returns 128 bit result of lhs * rhs
+++ inline ExtendedMultResult<std::uint64_t>
+++ extendedMult( std::uint64_t lhs, std::uint64_t rhs ) {
+++#if defined( CATCH_CONFIG_UINT128 )
+++ auto result = __uint128_t( lhs ) * __uint128_t( rhs );
+++ return { static_cast<std::uint64_t>( result >> 64 ),
+++ static_cast<std::uint64_t>( result ) };
+++#elif defined( CATCH_CONFIG_MSVC_UMUL128 )
+++ std::uint64_t high;
+++ std::uint64_t low = _umul128( lhs, rhs, &high );
+++ return { high, low };
+++#else
+++ return extendedMultPortable( lhs, rhs );
+++#endif
+++ }
+++
+++
+++ template <typename UInt>
+++ constexpr ExtendedMultResult<UInt> extendedMult( UInt lhs, UInt rhs ) {
+++ static_assert( std::is_unsigned<UInt>::value,
+++ "extendedMult can only handle unsigned integers" );
+++ static_assert( sizeof( UInt ) < sizeof( std::uint64_t ),
+++ "Generic extendedMult can only handle types smaller "
+++ "than uint64_t" );
+++ using WideType = DoubleWidthUnsignedType_t<UInt>;
+++
+++ auto result = WideType( lhs ) * WideType( rhs );
+++ return {
+++ static_cast<UInt>( result >> ( CHAR_BIT * sizeof( UInt ) ) ),
+++ static_cast<UInt>( result & UInt( -1 ) ) };
+++ }
+++
+++
+++ template <typename TargetType,
+++ typename Generator>
+++ std::enable_if_t<sizeof(typename Generator::result_type) >= sizeof(TargetType),
+++ TargetType> fillBitsFrom(Generator& gen) {
+++ using gresult_type = typename Generator::result_type;
+++ static_assert( std::is_unsigned<TargetType>::value, "Only unsigned integers are supported" );
+++ static_assert( Generator::min() == 0 &&
+++ Generator::max() == static_cast<gresult_type>( -1 ),
+++ "Generator must be able to output all numbers in its result type (effectively it must be a random bit generator)" );
+++
+++ // We want to return the top bits from a generator, as they are
+++ // usually considered higher quality.
+++ constexpr auto generated_bits = sizeof( gresult_type ) * CHAR_BIT;
+++ constexpr auto return_bits = sizeof( TargetType ) * CHAR_BIT;
+++
+++ return static_cast<TargetType>( gen() >>
+++ ( generated_bits - return_bits) );
+++ }
+++
+++ template <typename TargetType,
+++ typename Generator>
+++ std::enable_if_t<sizeof(typename Generator::result_type) < sizeof(TargetType),
+++ TargetType> fillBitsFrom(Generator& gen) {
+++ using gresult_type = typename Generator::result_type;
+++ static_assert( std::is_unsigned<TargetType>::value,
+++ "Only unsigned integers are supported" );
+++ static_assert( Generator::min() == 0 &&
+++ Generator::max() == static_cast<gresult_type>( -1 ),
+++ "Generator must be able to output all numbers in its result type (effectively it must be a random bit generator)" );
+++
+++ constexpr auto generated_bits = sizeof( gresult_type ) * CHAR_BIT;
+++ constexpr auto return_bits = sizeof( TargetType ) * CHAR_BIT;
+++ std::size_t filled_bits = 0;
+++ TargetType ret = 0;
+++ do {
+++ ret <<= generated_bits;
+++ ret |= gen();
+++ filled_bits += generated_bits;
+++ } while ( filled_bits < return_bits );
+++
+++ return ret;
+++ }
+++
+++ /*
+++ * Transposes numbers into unsigned type while keeping their ordering
+++ *
+++ * This means that signed types are changed so that the ordering is
+++ * [INT_MIN, ..., -1, 0, ..., INT_MAX], rather than order we would
+++ * get by simple casting ([0, ..., INT_MAX, INT_MIN, ..., -1])
+++ */
+++ template <typename OriginalType, typename UnsignedType>
+++ std::enable_if_t<std::is_signed<OriginalType>::value, UnsignedType>
+++ transposeToNaturalOrder( UnsignedType in ) {
+++ static_assert(
+++ sizeof( OriginalType ) == sizeof( UnsignedType ),
+++ "reordering requires the same sized types on both sides" );
+++ static_assert( std::is_unsigned<UnsignedType>::value,
+++ "Input type must be unsigned" );
+++ // Assuming 2s complement (standardized in current C++), the
+++ // positive and negative numbers are already internally ordered,
+++ // and their difference is in the top bit. Swapping it orders
+++ // them the desired way.
+++ constexpr auto highest_bit =
+++ UnsignedType( 1 ) << ( sizeof( UnsignedType ) * CHAR_BIT - 1 );
+++ return static_cast<UnsignedType>( in ^ highest_bit );
+++ }
+++
+++
+++
+++ template <typename OriginalType,
+++ typename UnsignedType>
+++ std::enable_if_t<std::is_unsigned<OriginalType>::value, UnsignedType>
+++ transposeToNaturalOrder(UnsignedType in) {
+++ static_assert(
+++ sizeof( OriginalType ) == sizeof( UnsignedType ),
+++ "reordering requires the same sized types on both sides" );
+++ static_assert( std::is_unsigned<UnsignedType>::value, "Input type must be unsigned" );
+++ // No reordering is needed for unsigned -> unsigned
+++ return in;
+++ }
+++ } // namespace Detail
+++} // namespace Catch
+++
+++#endif // CATCH_RANDOM_INTEGER_HELPERS_HPP_INCLUDED
+++
+++namespace Catch {
+++
+++/**
+++ * Implementation of uniform distribution on integers.
+++ *
+++ * Unlike `std::uniform_int_distribution`, this implementation supports
+++ * various 1 byte integral types, including bool (but you should not
+++ * actually use it for bools).
+++ *
+++ * The underlying algorithm is based on the one described in "Fast Random
+++ * Integer Generation in an Interval" by Daniel Lemire, but has been
+++ * optimized under the assumption of reuse of the same distribution object.
+++ */
+++template <typename IntegerType>
+++class uniform_integer_distribution {
+++ static_assert(std::is_integral<IntegerType>::value, "...");
+++
+++ using UnsignedIntegerType = Detail::SizedUnsignedType_t<sizeof(IntegerType)>;
+++
+++ // Only the left bound is stored, and we store it converted to its
+++ // unsigned image. This avoids having to do the conversions inside
+++ // the operator(), at the cost of having to do the conversion in
+++ // the a() getter. The right bound is only needed in the b() getter,
+++ // so we recompute it there from other stored data.
+++ UnsignedIntegerType m_a;
+++
+++ // How many different values are there in [a, b]. a == b => 1, can be 0 for distribution over all values in the type.
+++ UnsignedIntegerType m_ab_distance;
+++
+++ // We hoisted this out of the main generation function. Technically,
+++ // this means that using this distribution will be slower than Lemire's
+++ // algorithm if this distribution instance will be used only few times,
+++ // but it will be faster if it is used many times. Since Catch2 uses
+++ // distributions only to implement random generators, we assume that each
+++ // distribution will be reused many times and this is an optimization.
+++ UnsignedIntegerType m_rejection_threshold = 0;
+++
+++ UnsignedIntegerType computeDistance(IntegerType a, IntegerType b) const {
+++ // This overflows and returns 0 if a == 0 and b == TYPE_MAX.
+++ // We handle that later when generating the number.
+++ return transposeTo(b) - transposeTo(a) + 1;
+++ }
+++
+++ static UnsignedIntegerType computeRejectionThreshold(UnsignedIntegerType ab_distance) {
+++ // distance == 0 means that we will return all possible values from
+++ // the type's range, and that we shouldn't reject anything.
+++ if ( ab_distance == 0 ) { return 0; }
+++ return ( ~ab_distance + 1 ) % ab_distance;
+++ }
+++
+++ static UnsignedIntegerType transposeTo(IntegerType in) {
+++ return Detail::transposeToNaturalOrder<IntegerType>(
+++ static_cast<UnsignedIntegerType>( in ) );
+++ }
+++ static IntegerType transposeBack(UnsignedIntegerType in) {
+++ return static_cast<IntegerType>(
+++ Detail::transposeToNaturalOrder<IntegerType>(in) );
+++ }
+++
+++public:
+++ using result_type = IntegerType;
+++
+++ uniform_integer_distribution( IntegerType a, IntegerType b ):
+++ m_a( transposeTo(a) ),
+++ m_ab_distance( computeDistance(a, b) ),
+++ m_rejection_threshold( computeRejectionThreshold(m_ab_distance) ) {
+++ assert( a <= b );
+++ }
+++
+++ template <typename Generator>
+++ result_type operator()( Generator& g ) {
+++ // All possible values of result_type are valid.
+++ if ( m_ab_distance == 0 ) {
+++ return transposeBack( Detail::fillBitsFrom<UnsignedIntegerType>( g ) );
+++ }
+++
+++ auto random_number = Detail::fillBitsFrom<UnsignedIntegerType>( g );
+++ auto emul = Detail::extendedMult( random_number, m_ab_distance );
+++ // Unlike Lemire's algorithm we skip the ab_distance check, since
+++ // we precomputed the rejection threshold, which is always tighter.
+++ while (emul.lower < m_rejection_threshold) {
+++ random_number = Detail::fillBitsFrom<UnsignedIntegerType>( g );
+++ emul = Detail::extendedMult( random_number, m_ab_distance );
+++ }
+++
+++ return transposeBack(m_a + emul.upper);
+++ }
+++
+++ result_type a() const { return transposeBack(m_a); }
+++ result_type b() const { return transposeBack(m_ab_distance + m_a - 1); }
+++};
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_UNIFORM_INTEGER_DISTRIBUTION_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
+++#define CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
+++
+++
+++
+++
+++#ifndef CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED
+++#define CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_POLYFILLS_HPP_INCLUDED
+++#define CATCH_POLYFILLS_HPP_INCLUDED
+++
+++namespace Catch {
+++
+++ bool isnan(float f);
+++ bool isnan(double d);
+++
+++ float nextafter(float x, float y);
+++ double nextafter(double x, double y);
+++
+++}
+++
+++#endif // CATCH_POLYFILLS_HPP_INCLUDED
+++
+++#include <cassert>
+++#include <cmath>
+++#include <cstdint>
+++#include <limits>
+++#include <type_traits>
+++
+++namespace Catch {
+++
+++ namespace Detail {
+++ /**
+++ * Returns the largest magnitude of 1-ULP distance inside the [a, b] range.
+++ *
+++ * Assumes `a < b`.
+++ */
+++ template <typename FloatType>
+++ FloatType gamma(FloatType a, FloatType b) {
+++ static_assert( std::is_floating_point<FloatType>::value,
+++ "gamma returns the largest ULP magnitude within "
+++ "floating point range [a, b]. This only makes sense "
+++ "for floating point types" );
+++ assert( a <= b );
+++
+++ const auto gamma_up = Catch::nextafter( a, std::numeric_limits<FloatType>::infinity() ) - a;
+++ const auto gamma_down = b - Catch::nextafter( b, -std::numeric_limits<FloatType>::infinity() );
+++
+++ return gamma_up < gamma_down ? gamma_down : gamma_up;
+++ }
+++
+++ template <typename FloatingPoint>
+++ struct DistanceTypePicker;
+++ template <>
+++ struct DistanceTypePicker<float> {
+++ using type = std::uint32_t;
+++ };
+++ template <>
+++ struct DistanceTypePicker<double> {
+++ using type = std::uint64_t;
+++ };
+++
+++ template <typename T>
+++ using DistanceType = typename DistanceTypePicker<T>::type;
+++
+++#if defined( __GNUC__ ) || defined( __clang__ )
+++# pragma GCC diagnostic push
+++# pragma GCC diagnostic ignored "-Wfloat-equal"
+++#endif
+++ /**
+++ * Computes the number of equi-distant floats in [a, b]
+++ *
+++ * Since not every range can be split into equidistant floats
+++ * exactly, we actually compute ceil(b/distance - a/distance),
+++ * because in those cases we want to overcount.
+++ *
+++ * Uses modified Dekker's FastTwoSum algorithm to handle rounding.
+++ */
+++ template <typename FloatType>
+++ DistanceType<FloatType>
+++ count_equidistant_floats( FloatType a, FloatType b, FloatType distance ) {
+++ assert( a <= b );
+++ // We get distance as gamma for our uniform float distribution,
+++ // so this will round perfectly.
+++ const auto ag = a / distance;
+++ const auto bg = b / distance;
+++
+++ const auto s = bg - ag;
+++ const auto err = ( std::fabs( a ) <= std::fabs( b ) )
+++ ? -ag - ( s - bg )
+++ : bg - ( s + ag );
+++ const auto ceil_s = static_cast<DistanceType<FloatType>>( std::ceil( s ) );
+++
+++ return ( ceil_s != s ) ? ceil_s : ceil_s + ( err > 0 );
+++ }
+++#if defined( __GNUC__ ) || defined( __clang__ )
+++# pragma GCC diagnostic pop
+++#endif
+++
+++ }
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_RANDOM_FLOATING_POINT_HELPERS_HPP_INCLUDED
+++
+++#include <cmath>
+++#include <type_traits>
+++
+++namespace Catch {
+++
+++ namespace Detail {
+++#if defined( __GNUC__ ) || defined( __clang__ )
+++# pragma GCC diagnostic push
+++# pragma GCC diagnostic ignored "-Wfloat-equal"
+++#endif
+++ // The issue with overflow only happens with maximal ULP and HUGE
+++ // distance, e.g. when generating numbers in [-inf, inf] for given
+++ // type. So we only check for the largest possible ULP in the
+++ // type, and return something that does not overflow to inf in 1 mult.
+++ constexpr std::uint64_t calculate_max_steps_in_one_go(double gamma) {
+++ if ( gamma == 1.99584030953472e+292 ) { return 9007199254740991; }
+++ return static_cast<std::uint64_t>( -1 );
+++ }
+++ constexpr std::uint32_t calculate_max_steps_in_one_go(float gamma) {
+++ if ( gamma == 2.028241e+31f ) { return 16777215; }
+++ return static_cast<std::uint32_t>( -1 );
+++ }
+++#if defined( __GNUC__ ) || defined( __clang__ )
+++# pragma GCC diagnostic pop
+++#endif
+++ }
+++
+++/**
+++ * Implementation of uniform distribution on floating point numbers.
+++ *
+++ * Note that we support only `float` and `double` types, because these
+++ * usually mean the same thing across different platform. `long double`
+++ * varies wildly by platform and thus we cannot provide reproducible
+++ * implementation. Also note that we don't implement all parts of
+++ * distribution per standard: this distribution is not serializable, nor
+++ * can the range be arbitrarily reset.
+++ *
+++ * The implementation also uses different approach than the one taken by
+++ * `std::uniform_real_distribution`, where instead of generating a number
+++ * between [0, 1) and then multiplying the range bounds with it, we first
+++ * split the [a, b] range into a set of equidistributed floating point
+++ * numbers, and then use uniform int distribution to pick which one to
+++ * return.
+++ *
+++ * This has the advantage of guaranteeing uniformity (the multiplication
+++ * method loses uniformity due to rounding when multiplying floats), except
+++ * for small non-uniformity at one side of the interval, where we have
+++ * to deal with the fact that not every interval is splittable into
+++ * equidistributed floats.
+++ *
+++ * Based on "Drawing random floating-point numbers from an interval" by
+++ * Frederic Goualard.
+++ */
+++template <typename FloatType>
+++class uniform_floating_point_distribution {
+++ static_assert(std::is_floating_point<FloatType>::value, "...");
+++ static_assert(!std::is_same<FloatType, long double>::value,
+++ "We do not support long double due to inconsistent behaviour between platforms");
+++
+++ using WidthType = Detail::DistanceType<FloatType>;
+++
+++ FloatType m_a, m_b;
+++ FloatType m_ulp_magnitude;
+++ WidthType m_floats_in_range;
+++ uniform_integer_distribution<WidthType> m_int_dist;
+++
+++ // In specific cases, we can overflow into `inf` when computing the
+++ // `steps * g` offset. To avoid this, we don't offset by more than this
+++ // in one multiply + addition.
+++ WidthType m_max_steps_in_one_go;
+++ // We don't want to do the magnitude check every call to `operator()`
+++ bool m_a_has_leq_magnitude;
+++
+++public:
+++ using result_type = FloatType;
+++
+++ uniform_floating_point_distribution( FloatType a, FloatType b ):
+++ m_a( a ),
+++ m_b( b ),
+++ m_ulp_magnitude( Detail::gamma( m_a, m_b ) ),
+++ m_floats_in_range( Detail::count_equidistant_floats( m_a, m_b, m_ulp_magnitude ) ),
+++ m_int_dist(0, m_floats_in_range),
+++ m_max_steps_in_one_go( Detail::calculate_max_steps_in_one_go(m_ulp_magnitude)),
+++ m_a_has_leq_magnitude(std::fabs(m_a) <= std::fabs(m_b))
+++ {
+++ assert( a <= b );
+++ }
+++
+++ template <typename Generator>
+++ result_type operator()( Generator& g ) {
+++ WidthType steps = m_int_dist( g );
+++ if ( m_a_has_leq_magnitude ) {
+++ if ( steps == m_floats_in_range ) { return m_a; }
+++ auto b = m_b;
+++ while (steps > m_max_steps_in_one_go) {
+++ b -= m_max_steps_in_one_go * m_ulp_magnitude;
+++ steps -= m_max_steps_in_one_go;
+++ }
+++ return b - steps * m_ulp_magnitude;
+++ } else {
+++ if ( steps == m_floats_in_range ) { return m_b; }
+++ auto a = m_a;
+++ while (steps > m_max_steps_in_one_go) {
+++ a += m_max_steps_in_one_go * m_ulp_magnitude;
+++ steps -= m_max_steps_in_one_go;
+++ }
+++ return a + steps * m_ulp_magnitude;
+++ }
+++ }
+++
+++ result_type a() const { return m_a; }
+++ result_type b() const { return m_b; }
+++};
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_UNIFORM_FLOATING_POINT_DISTRIBUTION_HPP_INCLUDED
+++
+++namespace Catch {
+++namespace Generators {
+++namespace Detail {
+++ // Returns a suitable seed for a random floating generator based off
+++ // the primary internal rng. It does so by taking current value from
+++ // the rng and returning it as the seed.
+++ std::uint32_t getSeed();
+++}
+++
+++template <typename Float>
+++class RandomFloatingGenerator final : public IGenerator<Float> {
+++ Catch::SimplePcg32 m_rng;
+++ Catch::uniform_floating_point_distribution<Float> m_dist;
+++ Float m_current_number;
+++public:
+++ RandomFloatingGenerator( Float a, Float b, std::uint32_t seed ):
+++ m_rng(seed),
+++ m_dist(a, b) {
+++ static_cast<void>(next());
+++ }
+++
+++ Float const& get() const override {
+++ return m_current_number;
+++ }
+++ bool next() override {
+++ m_current_number = m_dist(m_rng);
+++ return true;
+++ }
+++};
+++
+++template <>
+++class RandomFloatingGenerator<long double> final : public IGenerator<long double> {
+++ // We still rely on <random> for this specialization, but we don't
+++ // want to drag it into the header.
+++ struct PImpl;
+++ Catch::Detail::unique_ptr<PImpl> m_pimpl;
+++ long double m_current_number;
+++
+++public:
+++ RandomFloatingGenerator( long double a, long double b, std::uint32_t seed );
+++
+++ long double const& get() const override { return m_current_number; }
+++ bool next() override;
+++
+++ ~RandomFloatingGenerator() override; // = default
+++};
+++
+++template <typename Integer>
+++class RandomIntegerGenerator final : public IGenerator<Integer> {
+++ Catch::SimplePcg32 m_rng;
+++ Catch::uniform_integer_distribution<Integer> m_dist;
+++ Integer m_current_number;
+++public:
+++ RandomIntegerGenerator( Integer a, Integer b, std::uint32_t seed ):
+++ m_rng(seed),
+++ m_dist(a, b) {
+++ static_cast<void>(next());
+++ }
+++
+++ Integer const& get() const override {
+++ return m_current_number;
+++ }
+++ bool next() override {
+++ m_current_number = m_dist(m_rng);
+++ return true;
+++ }
+++};
+++
+++template <typename T>
+++std::enable_if_t<std::is_integral<T>::value, GeneratorWrapper<T>>
+++random(T a, T b) {
+++ return GeneratorWrapper<T>(
+++ Catch::Detail::make_unique<RandomIntegerGenerator<T>>(a, b, Detail::getSeed())
+++ );
+++}
+++
+++template <typename T>
+++std::enable_if_t<std::is_floating_point<T>::value,
+++GeneratorWrapper<T>>
+++random(T a, T b) {
+++ return GeneratorWrapper<T>(
+++ Catch::Detail::make_unique<RandomFloatingGenerator<T>>(a, b, Detail::getSeed())
+++ );
+++}
+++
+++
+++} // namespace Generators
+++} // namespace Catch
+++
+++
+++#endif // CATCH_GENERATORS_RANDOM_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_GENERATORS_RANGE_HPP_INCLUDED
+++#define CATCH_GENERATORS_RANGE_HPP_INCLUDED
+++
+++
+++#include <iterator>
+++#include <type_traits>
+++
+++namespace Catch {
+++namespace Generators {
+++
+++
+++template <typename T>
+++class RangeGenerator final : public IGenerator<T> {
+++ T m_current;
+++ T m_end;
+++ T m_step;
+++ bool m_positive;
+++
+++public:
+++ RangeGenerator(T const& start, T const& end, T const& step):
+++ m_current(start),
+++ m_end(end),
+++ m_step(step),
+++ m_positive(m_step > T(0))
+++ {
+++ assert(m_current != m_end && "Range start and end cannot be equal");
+++ assert(m_step != T(0) && "Step size cannot be zero");
+++ assert(((m_positive && m_current <= m_end) || (!m_positive && m_current >= m_end)) && "Step moves away from end");
+++ }
+++
+++ RangeGenerator(T const& start, T const& end):
+++ RangeGenerator(start, end, (start < end) ? T(1) : T(-1))
+++ {}
+++
+++ T const& get() const override {
+++ return m_current;
+++ }
+++
+++ bool next() override {
+++ m_current += m_step;
+++ return (m_positive) ? (m_current < m_end) : (m_current > m_end);
+++ }
+++};
+++
+++template <typename T>
+++GeneratorWrapper<T> range(T const& start, T const& end, T const& step) {
+++ static_assert(std::is_arithmetic<T>::value && !std::is_same<T, bool>::value, "Type must be numeric");
+++ return GeneratorWrapper<T>(Catch::Detail::make_unique<RangeGenerator<T>>(start, end, step));
+++}
+++
+++template <typename T>
+++GeneratorWrapper<T> range(T const& start, T const& end) {
+++ static_assert(std::is_integral<T>::value && !std::is_same<T, bool>::value, "Type must be an integer");
+++ return GeneratorWrapper<T>(Catch::Detail::make_unique<RangeGenerator<T>>(start, end));
+++}
+++
+++
+++template <typename T>
+++class IteratorGenerator final : public IGenerator<T> {
+++ static_assert(!std::is_same<T, bool>::value,
+++ "IteratorGenerator currently does not support bools"
+++ "because of std::vector<bool> specialization");
+++
+++ std::vector<T> m_elems;
+++ size_t m_current = 0;
+++public:
+++ template <typename InputIterator, typename InputSentinel>
+++ IteratorGenerator(InputIterator first, InputSentinel last):m_elems(first, last) {
+++ if (m_elems.empty()) {
+++ Detail::throw_generator_exception("IteratorGenerator received no valid values");
+++ }
+++ }
+++
+++ T const& get() const override {
+++ return m_elems[m_current];
+++ }
+++
+++ bool next() override {
+++ ++m_current;
+++ return m_current != m_elems.size();
+++ }
+++};
+++
+++template <typename InputIterator,
+++ typename InputSentinel,
+++ typename ResultType = typename std::iterator_traits<InputIterator>::value_type>
+++GeneratorWrapper<ResultType> from_range(InputIterator from, InputSentinel to) {
+++ return GeneratorWrapper<ResultType>(Catch::Detail::make_unique<IteratorGenerator<ResultType>>(from, to));
+++}
+++
+++template <typename Container>
+++auto from_range(Container const& cnt) {
+++ using std::begin;
+++ using std::end;
+++ return from_range( begin( cnt ), end( cnt ) );
+++}
+++
+++
+++} // namespace Generators
+++} // namespace Catch
+++
+++
+++#endif // CATCH_GENERATORS_RANGE_HPP_INCLUDED
+++
+++#endif // CATCH_GENERATORS_ALL_HPP_INCLUDED
+++
+++
+++/** \file
+++ * This is a convenience header for Catch2's interfaces. It includes
+++ * **all** of Catch2 headers related to interfaces.
+++ *
+++ * Generally the Catch2 users should use specific includes they need,
+++ * but this header can be used instead for ease-of-experimentation, or
+++ * just plain convenience, at the cost of somewhat increased compilation
+++ * times.
+++ *
+++ * When a new header is added to either the `interfaces` folder, or to
+++ * the corresponding internal subfolder, it should be added here.
+++ */
+++
+++
+++#ifndef CATCH_INTERFACES_ALL_HPP_INCLUDED
+++#define CATCH_INTERFACES_ALL_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_INTERFACES_REPORTER_HPP_INCLUDED
+++#define CATCH_INTERFACES_REPORTER_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_TEST_RUN_INFO_HPP_INCLUDED
+++#define CATCH_TEST_RUN_INFO_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++
+++ struct TestRunInfo {
+++ constexpr TestRunInfo(StringRef _name) : name(_name) {}
+++ StringRef name;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_TEST_RUN_INFO_HPP_INCLUDED
+++
+++#include <map>
+++#include <string>
+++#include <vector>
+++#include <iosfwd>
+++
+++namespace Catch {
+++
+++ struct ReporterDescription;
+++ struct ListenerDescription;
+++ struct TagInfo;
+++ struct TestCaseInfo;
+++ class TestCaseHandle;
+++ class IConfig;
+++ class IStream;
+++ enum class ColourMode : std::uint8_t;
+++
+++ struct ReporterConfig {
+++ ReporterConfig( IConfig const* _fullConfig,
+++ Detail::unique_ptr<IStream> _stream,
+++ ColourMode colourMode,
+++ std::map<std::string, std::string> customOptions );
+++
+++ ReporterConfig( ReporterConfig&& ) = default;
+++ ReporterConfig& operator=( ReporterConfig&& ) = default;
+++ ~ReporterConfig(); // = default
+++
+++ Detail::unique_ptr<IStream> takeStream() &&;
+++ IConfig const* fullConfig() const;
+++ ColourMode colourMode() const;
+++ std::map<std::string, std::string> const& customOptions() const;
+++
+++ private:
+++ Detail::unique_ptr<IStream> m_stream;
+++ IConfig const* m_fullConfig;
+++ ColourMode m_colourMode;
+++ std::map<std::string, std::string> m_customOptions;
+++ };
+++
+++ struct AssertionStats {
+++ AssertionStats( AssertionResult const& _assertionResult,
+++ std::vector<MessageInfo> const& _infoMessages,
+++ Totals const& _totals );
+++
+++ AssertionStats( AssertionStats const& ) = default;
+++ AssertionStats( AssertionStats && ) = default;
+++ AssertionStats& operator = ( AssertionStats const& ) = delete;
+++ AssertionStats& operator = ( AssertionStats && ) = delete;
+++
+++ AssertionResult assertionResult;
+++ std::vector<MessageInfo> infoMessages;
+++ Totals totals;
+++ };
+++
+++ struct SectionStats {
+++ SectionStats( SectionInfo&& _sectionInfo,
+++ Counts const& _assertions,
+++ double _durationInSeconds,
+++ bool _missingAssertions );
+++
+++ SectionInfo sectionInfo;
+++ Counts assertions;
+++ double durationInSeconds;
+++ bool missingAssertions;
+++ };
+++
+++ struct TestCaseStats {
+++ TestCaseStats( TestCaseInfo const& _testInfo,
+++ Totals const& _totals,
+++ std::string&& _stdOut,
+++ std::string&& _stdErr,
+++ bool _aborting );
+++
+++ TestCaseInfo const * testInfo;
+++ Totals totals;
+++ std::string stdOut;
+++ std::string stdErr;
+++ bool aborting;
+++ };
+++
+++ struct TestRunStats {
+++ TestRunStats( TestRunInfo const& _runInfo,
+++ Totals const& _totals,
+++ bool _aborting );
+++
+++ TestRunInfo runInfo;
+++ Totals totals;
+++ bool aborting;
+++ };
+++
+++ //! By setting up its preferences, a reporter can modify Catch2's behaviour
+++ //! in some regards, e.g. it can request Catch2 to capture writes to
+++ //! stdout/stderr during test execution, and pass them to the reporter.
+++ struct ReporterPreferences {
+++ //! Catch2 should redirect writes to stdout and pass them to the
+++ //! reporter
+++ bool shouldRedirectStdOut = false;
+++ //! Catch2 should call `Reporter::assertionEnded` even for passing
+++ //! assertions
+++ bool shouldReportAllAssertions = false;
+++ };
+++
+++ /**
+++ * The common base for all reporters and event listeners
+++ *
+++ * Implementing classes must also implement:
+++ *
+++ * //! User-friendly description of the reporter/listener type
+++ * static std::string getDescription()
+++ *
+++ * Generally shouldn't be derived from by users of Catch2 directly,
+++ * instead they should derive from one of the utility bases that
+++ * derive from this class.
+++ */
+++ class IEventListener {
+++ protected:
+++ //! Derived classes can set up their preferences here
+++ ReporterPreferences m_preferences;
+++ //! The test run's config as filled in from CLI and defaults
+++ IConfig const* m_config;
+++
+++ public:
+++ IEventListener( IConfig const* config ): m_config( config ) {}
+++
+++ virtual ~IEventListener(); // = default;
+++
+++ // Implementing class must also provide the following static methods:
+++ // static std::string getDescription();
+++
+++ ReporterPreferences const& getPreferences() const {
+++ return m_preferences;
+++ }
+++
+++ //! Called when no test cases match provided test spec
+++ virtual void noMatchingTestCases( StringRef unmatchedSpec ) = 0;
+++ //! Called for all invalid test specs from the cli
+++ virtual void reportInvalidTestSpec( StringRef invalidArgument ) = 0;
+++
+++ /**
+++ * Called once in a testing run before tests are started
+++ *
+++ * Not called if tests won't be run (e.g. only listing will happen)
+++ */
+++ virtual void testRunStarting( TestRunInfo const& testRunInfo ) = 0;
+++
+++ //! Called _once_ for each TEST_CASE, no matter how many times it is entered
+++ virtual void testCaseStarting( TestCaseInfo const& testInfo ) = 0;
+++ //! Called _every time_ a TEST_CASE is entered, including repeats (due to sections)
+++ virtual void testCasePartialStarting( TestCaseInfo const& testInfo, uint64_t partNumber ) = 0;
+++ //! Called when a `SECTION` is being entered. Not called for skipped sections
+++ virtual void sectionStarting( SectionInfo const& sectionInfo ) = 0;
+++
+++ //! Called when user-code is being probed before the actual benchmark runs
+++ virtual void benchmarkPreparing( StringRef benchmarkName ) = 0;
+++ //! Called after probe but before the user-code is being benchmarked
+++ virtual void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) = 0;
+++ //! Called with the benchmark results if benchmark successfully finishes
+++ virtual void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) = 0;
+++ //! Called if running the benchmarks fails for any reason
+++ virtual void benchmarkFailed( StringRef benchmarkName ) = 0;
+++
+++ //! Called before assertion success/failure is evaluated
+++ virtual void assertionStarting( AssertionInfo const& assertionInfo ) = 0;
+++
+++ //! Called after assertion was fully evaluated
+++ virtual void assertionEnded( AssertionStats const& assertionStats ) = 0;
+++
+++ //! Called after a `SECTION` has finished running
+++ virtual void sectionEnded( SectionStats const& sectionStats ) = 0;
+++ //! Called _every time_ a TEST_CASE is entered, including repeats (due to sections)
+++ virtual void testCasePartialEnded(TestCaseStats const& testCaseStats, uint64_t partNumber ) = 0;
+++ //! Called _once_ for each TEST_CASE, no matter how many times it is entered
+++ virtual void testCaseEnded( TestCaseStats const& testCaseStats ) = 0;
+++ /**
+++ * Called once after all tests in a testing run are finished
+++ *
+++ * Not called if tests weren't run (e.g. only listings happened)
+++ */
+++ virtual void testRunEnded( TestRunStats const& testRunStats ) = 0;
+++
+++ /**
+++ * Called with test cases that are skipped due to the test run aborting.
+++ * NOT called for test cases that are explicitly skipped using the `SKIP` macro.
+++ *
+++ * Deprecated - will be removed in the next major release.
+++ */
+++ virtual void skipTest( TestCaseInfo const& testInfo ) = 0;
+++
+++ //! Called if a fatal error (signal/structured exception) occurred
+++ virtual void fatalErrorEncountered( StringRef error ) = 0;
+++
+++ //! Writes out information about provided reporters using reporter-specific format
+++ virtual void listReporters(std::vector<ReporterDescription> const& descriptions) = 0;
+++ //! Writes out the provided listeners descriptions using reporter-specific format
+++ virtual void listListeners(std::vector<ListenerDescription> const& descriptions) = 0;
+++ //! Writes out information about provided tests using reporter-specific format
+++ virtual void listTests(std::vector<TestCaseHandle> const& tests) = 0;
+++ //! Writes out information about the provided tags using reporter-specific format
+++ virtual void listTags(std::vector<TagInfo> const& tags) = 0;
+++ };
+++ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_INTERFACES_REPORTER_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
+++#define CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
+++
+++
+++#include <string>
+++
+++namespace Catch {
+++
+++ struct ReporterConfig;
+++ class IConfig;
+++ class IEventListener;
+++ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+++
+++
+++ class IReporterFactory {
+++ public:
+++ virtual ~IReporterFactory(); // = default
+++
+++ virtual IEventListenerPtr
+++ create( ReporterConfig&& config ) const = 0;
+++ virtual std::string getDescription() const = 0;
+++ };
+++ using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
+++
+++ class EventListenerFactory {
+++ public:
+++ virtual ~EventListenerFactory(); // = default
+++ virtual IEventListenerPtr create( IConfig const* config ) const = 0;
+++ //! Return a meaningful name for the listener, e.g. its type name
+++ virtual StringRef getName() const = 0;
+++ //! Return listener's description if available
+++ virtual std::string getDescription() const = 0;
+++ };
+++} // namespace Catch
+++
+++#endif // CATCH_INTERFACES_REPORTER_FACTORY_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+++#define CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+++
+++#include <string>
+++
+++namespace Catch {
+++
+++ struct TagAlias;
+++
+++ class ITagAliasRegistry {
+++ public:
+++ virtual ~ITagAliasRegistry(); // = default
+++ // Nullptr if not present
+++ virtual TagAlias const* find( std::string const& alias ) const = 0;
+++ virtual std::string expandAliases( std::string const& unexpandedTestSpec ) const = 0;
+++
+++ static ITagAliasRegistry const& get();
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_INTERFACES_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
+++#define CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
+++
+++#include <vector>
+++
+++namespace Catch {
+++
+++ struct TestCaseInfo;
+++ class TestCaseHandle;
+++ class IConfig;
+++
+++ class ITestCaseRegistry {
+++ public:
+++ virtual ~ITestCaseRegistry(); // = default
+++ // TODO: this exists only for adding filenames to test cases -- let's expose this in a saner way later
+++ virtual std::vector<TestCaseInfo* > const& getAllInfos() const = 0;
+++ virtual std::vector<TestCaseHandle> const& getAllTests() const = 0;
+++ virtual std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const = 0;
+++ };
+++
+++}
+++
+++#endif // CATCH_INTERFACES_TESTCASE_HPP_INCLUDED
+++
+++#endif // CATCH_INTERFACES_ALL_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
+++#define CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++ namespace Detail {
+++ //! Provides case-insensitive `op<` semantics when called
+++ struct CaseInsensitiveLess {
+++ bool operator()( StringRef lhs,
+++ StringRef rhs ) const;
+++ };
+++
+++ //! Provides case-insensitive `op==` semantics when called
+++ struct CaseInsensitiveEqualTo {
+++ bool operator()( StringRef lhs,
+++ StringRef rhs ) const;
+++ };
+++
+++ } // namespace Detail
+++} // namespace Catch
+++
+++#endif // CATCH_CASE_INSENSITIVE_COMPARISONS_HPP_INCLUDED
+++
+++
+++
+++/** \file
+++ * Wrapper for ANDROID_LOGWRITE configuration option
+++ *
+++ * We want to default to enabling it when compiled for android, but
+++ * users of the library should also be able to disable it if they want
+++ * to.
+++ */
+++
+++#ifndef CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
+++#define CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
+++
+++
+++#if defined(__ANDROID__)
+++# define CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE
+++#endif
+++
+++
+++#if defined( CATCH_INTERNAL_CONFIG_ANDROID_LOGWRITE ) && \
+++ !defined( CATCH_CONFIG_NO_ANDROID_LOGWRITE ) && \
+++ !defined( CATCH_CONFIG_ANDROID_LOGWRITE )
+++# define CATCH_CONFIG_ANDROID_LOGWRITE
+++#endif
+++
+++#endif // CATCH_CONFIG_ANDROID_LOGWRITE_HPP_INCLUDED
+++
+++
+++
+++/** \file
+++ * Wrapper for UNCAUGHT_EXCEPTIONS configuration option
+++ *
+++ * For some functionality, Catch2 requires to know whether there is
+++ * an active exception. Because `std::uncaught_exception` is deprecated
+++ * in C++17, we want to use `std::uncaught_exceptions` if possible.
+++ */
+++
+++#ifndef CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+++#define CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+++
+++
+++#if defined(_MSC_VER)
+++# if _MSC_VER >= 1900 // Visual Studio 2015 or newer
+++# define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+++# endif
+++#endif
+++
+++
+++#include <exception>
+++
+++#if defined(__cpp_lib_uncaught_exceptions) \
+++ && !defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+++
+++# define CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+++#endif // __cpp_lib_uncaught_exceptions
+++
+++
+++#if defined(CATCH_INTERNAL_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS) \
+++ && !defined(CATCH_CONFIG_NO_CPP17_UNCAUGHT_EXCEPTIONS) \
+++ && !defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+++
+++# define CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS
+++#endif
+++
+++
+++#endif // CATCH_CONFIG_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+++#define CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+++
+++
+++#include <iosfwd>
+++#include <cstdint>
+++
+++namespace Catch {
+++
+++ enum class ColourMode : std::uint8_t;
+++ class IStream;
+++
+++ struct Colour {
+++ enum Code {
+++ None = 0,
+++
+++ White,
+++ Red,
+++ Green,
+++ Blue,
+++ Cyan,
+++ Yellow,
+++ Grey,
+++
+++ Bright = 0x10,
+++
+++ BrightRed = Bright | Red,
+++ BrightGreen = Bright | Green,
+++ LightGrey = Bright | Grey,
+++ BrightWhite = Bright | White,
+++ BrightYellow = Bright | Yellow,
+++
+++ // By intention
+++ FileName = LightGrey,
+++ Warning = BrightYellow,
+++ ResultError = BrightRed,
+++ ResultSuccess = BrightGreen,
+++ ResultExpectedFailure = Warning,
+++
+++ Error = BrightRed,
+++ Success = Green,
+++ Skip = LightGrey,
+++
+++ OriginalExpression = Cyan,
+++ ReconstructedExpression = BrightYellow,
+++
+++ SecondaryText = LightGrey,
+++ Headers = White
+++ };
+++ };
+++
+++ class ColourImpl {
+++ protected:
+++ //! The associated stream of this ColourImpl instance
+++ IStream* m_stream;
+++ public:
+++ ColourImpl( IStream* stream ): m_stream( stream ) {}
+++
+++ //! RAII wrapper around writing specific colour of text using specific
+++ //! colour impl into a stream.
+++ class ColourGuard {
+++ ColourImpl const* m_colourImpl;
+++ Colour::Code m_code;
+++ bool m_engaged = false;
+++
+++ public:
+++ //! Does **not** engage the guard/start the colour
+++ ColourGuard( Colour::Code code,
+++ ColourImpl const* colour );
+++
+++ ColourGuard( ColourGuard const& rhs ) = delete;
+++ ColourGuard& operator=( ColourGuard const& rhs ) = delete;
+++
+++ ColourGuard( ColourGuard&& rhs ) noexcept;
+++ ColourGuard& operator=( ColourGuard&& rhs ) noexcept;
+++
+++ //! Removes colour _if_ the guard was engaged
+++ ~ColourGuard();
+++
+++ /**
+++ * Explicitly engages colour for given stream.
+++ *
+++ * The API based on operator<< should be preferred.
+++ */
+++ ColourGuard& engage( std::ostream& stream ) &;
+++ /**
+++ * Explicitly engages colour for given stream.
+++ *
+++ * The API based on operator<< should be preferred.
+++ */
+++ ColourGuard&& engage( std::ostream& stream ) &&;
+++
+++ private:
+++ //! Engages the guard and starts using colour
+++ friend std::ostream& operator<<( std::ostream& lhs,
+++ ColourGuard& guard ) {
+++ guard.engageImpl( lhs );
+++ return lhs;
+++ }
+++ //! Engages the guard and starts using colour
+++ friend std::ostream& operator<<( std::ostream& lhs,
+++ ColourGuard&& guard) {
+++ guard.engageImpl( lhs );
+++ return lhs;
+++ }
+++
+++ void engageImpl( std::ostream& stream );
+++
+++ };
+++
+++ virtual ~ColourImpl(); // = default
+++ /**
+++ * Creates a guard object for given colour and this colour impl
+++ *
+++ * **Important:**
+++ * the guard starts disengaged, and has to be engaged explicitly.
+++ */
+++ ColourGuard guardColour( Colour::Code colourCode );
+++
+++ private:
+++ virtual void use( Colour::Code colourCode ) const = 0;
+++ };
+++
+++ //! Provides ColourImpl based on global config and target compilation platform
+++ Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode colourSelection,
+++ IStream* stream );
+++
+++ //! Checks if specific colour impl has been compiled into the binary
+++ bool isColourImplAvailable( ColourMode colourSelection );
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_CONSOLE_COLOUR_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_CONSOLE_WIDTH_HPP_INCLUDED
+++#define CATCH_CONSOLE_WIDTH_HPP_INCLUDED
+++
+++// This include must be kept so that user's configured value for CONSOLE_WIDTH
+++// is used before we attempt to provide a default value
+++
+++#ifndef CATCH_CONFIG_CONSOLE_WIDTH
+++#define CATCH_CONFIG_CONSOLE_WIDTH 80
+++#endif
+++
+++#endif // CATCH_CONSOLE_WIDTH_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
+++#define CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
+++
+++
+++#include <cstddef>
+++#include <initializer_list>
+++
+++// We want a simple polyfill over `std::empty`, `std::size` and so on
+++// for C++14 or C++ libraries with incomplete support.
+++// We also have to handle that MSVC std lib will happily provide these
+++// under older standards.
+++#if defined(CATCH_CPP17_OR_GREATER) || defined(_MSC_VER)
+++
+++// We are already using this header either way, so there shouldn't
+++// be much additional overhead in including it to get the feature
+++// test macros
+++#include <string>
+++
+++# if !defined(__cpp_lib_nonmember_container_access)
+++# define CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
+++# endif
+++
+++#else
+++#define CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
+++#endif
+++
+++
+++
+++namespace Catch {
+++namespace Detail {
+++
+++#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
+++ template <typename Container>
+++ constexpr auto empty(Container const& cont) -> decltype(cont.empty()) {
+++ return cont.empty();
+++ }
+++ template <typename T, std::size_t N>
+++ constexpr bool empty(const T (&)[N]) noexcept {
+++ // GCC < 7 does not support the const T(&)[] parameter syntax
+++ // so we have to ignore the length explicitly
+++ (void)N;
+++ return false;
+++ }
+++ template <typename T>
+++ constexpr bool empty(std::initializer_list<T> list) noexcept {
+++ return list.size() > 0;
+++ }
+++
+++
+++ template <typename Container>
+++ constexpr auto size(Container const& cont) -> decltype(cont.size()) {
+++ return cont.size();
+++ }
+++ template <typename T, std::size_t N>
+++ constexpr std::size_t size(const T(&)[N]) noexcept {
+++ return N;
+++ }
+++#endif // CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS
+++
+++} // end namespace Detail
+++} // end namespace Catch
+++
+++
+++
+++#endif // CATCH_CONTAINER_NONMEMBERS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_DEBUG_CONSOLE_HPP_INCLUDED
+++#define CATCH_DEBUG_CONSOLE_HPP_INCLUDED
+++
+++#include <string>
+++
+++namespace Catch {
+++ void writeToDebugConsole( std::string const& text );
+++}
+++
+++#endif // CATCH_DEBUG_CONSOLE_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_DEBUGGER_HPP_INCLUDED
+++#define CATCH_DEBUGGER_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++ bool isDebuggerActive();
+++}
+++
+++#ifdef CATCH_PLATFORM_MAC
+++
+++ #if defined(__i386__) || defined(__x86_64__)
+++ #define CATCH_TRAP() __asm__("int $3\n" : : ) /* NOLINT */
+++ #elif defined(__aarch64__)
+++ #define CATCH_TRAP() __asm__(".inst 0xd43e0000")
+++ #elif defined(__POWERPC__)
+++ #define CATCH_TRAP() __asm__("li r0, 20\nsc\nnop\nli r0, 37\nli r4, 2\nsc\nnop\n" \
+++ : : : "memory","r0","r3","r4" ) /* NOLINT */
+++ #endif
+++
+++#elif defined(CATCH_PLATFORM_IPHONE)
+++
+++ // use inline assembler
+++ #if defined(__i386__) || defined(__x86_64__)
+++ #define CATCH_TRAP() __asm__("int $3")
+++ #elif defined(__aarch64__)
+++ #define CATCH_TRAP() __asm__(".inst 0xd4200000")
+++ #elif defined(__arm__) && !defined(__thumb__)
+++ #define CATCH_TRAP() __asm__(".inst 0xe7f001f0")
+++ #elif defined(__arm__) && defined(__thumb__)
+++ #define CATCH_TRAP() __asm__(".inst 0xde01")
+++ #endif
+++
+++#elif defined(CATCH_PLATFORM_LINUX)
+++ // If we can use inline assembler, do it because this allows us to break
+++ // directly at the location of the failing check instead of breaking inside
+++ // raise() called from it, i.e. one stack frame below.
+++ #if defined(__GNUC__) && (defined(__i386) || defined(__x86_64))
+++ #define CATCH_TRAP() asm volatile ("int $3") /* NOLINT */
+++ #else // Fall back to the generic way.
+++ #include <signal.h>
+++
+++ #define CATCH_TRAP() raise(SIGTRAP)
+++ #endif
+++#elif defined(_MSC_VER)
+++ #define CATCH_TRAP() __debugbreak()
+++#elif defined(__MINGW32__)
+++ extern "C" __declspec(dllimport) void __stdcall DebugBreak();
+++ #define CATCH_TRAP() DebugBreak()
+++#endif
+++
+++#ifndef CATCH_BREAK_INTO_DEBUGGER
+++ #ifdef CATCH_TRAP
+++ #define CATCH_BREAK_INTO_DEBUGGER() []{ if( Catch::isDebuggerActive() ) { CATCH_TRAP(); } }()
+++ #else
+++ #define CATCH_BREAK_INTO_DEBUGGER() []{}()
+++ #endif
+++#endif
+++
+++#endif // CATCH_DEBUGGER_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_ENFORCE_HPP_INCLUDED
+++#define CATCH_ENFORCE_HPP_INCLUDED
+++
+++
+++#include <exception>
+++
+++namespace Catch {
+++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+++ template <typename Ex>
+++ [[noreturn]]
+++ void throw_exception(Ex const& e) {
+++ throw e;
+++ }
+++#else // ^^ Exceptions are enabled // Exceptions are disabled vv
+++ [[noreturn]]
+++ void throw_exception(std::exception const& e);
+++#endif
+++
+++ [[noreturn]]
+++ void throw_logic_error(std::string const& msg);
+++ [[noreturn]]
+++ void throw_domain_error(std::string const& msg);
+++ [[noreturn]]
+++ void throw_runtime_error(std::string const& msg);
+++
+++} // namespace Catch;
+++
+++#define CATCH_MAKE_MSG(...) \
+++ (Catch::ReusableStringStream() << __VA_ARGS__).str()
+++
+++#define CATCH_INTERNAL_ERROR(...) \
+++ Catch::throw_logic_error(CATCH_MAKE_MSG( CATCH_INTERNAL_LINEINFO << ": Internal Catch2 error: " << __VA_ARGS__))
+++
+++#define CATCH_ERROR(...) \
+++ Catch::throw_domain_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+++
+++#define CATCH_RUNTIME_ERROR(...) \
+++ Catch::throw_runtime_error(CATCH_MAKE_MSG( __VA_ARGS__ ))
+++
+++#define CATCH_ENFORCE( condition, ... ) \
+++ do{ if( !(condition) ) CATCH_ERROR( __VA_ARGS__ ); } while(false)
+++
+++
+++#endif // CATCH_ENFORCE_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+++#define CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+++
+++
+++#include <vector>
+++
+++namespace Catch {
+++
+++ namespace Detail {
+++
+++ Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values );
+++
+++ class EnumValuesRegistry : public IMutableEnumValuesRegistry {
+++
+++ std::vector<Catch::Detail::unique_ptr<EnumInfo>> m_enumInfos;
+++
+++ EnumInfo const& registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values) override;
+++ };
+++
+++ std::vector<StringRef> parseEnums( StringRef enums );
+++
+++ } // Detail
+++
+++} // Catch
+++
+++#endif // CATCH_ENUM_VALUES_REGISTRY_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_ERRNO_GUARD_HPP_INCLUDED
+++#define CATCH_ERRNO_GUARD_HPP_INCLUDED
+++
+++namespace Catch {
+++
+++ //! Simple RAII class that stores the value of `errno`
+++ //! at construction and restores it at destruction.
+++ class ErrnoGuard {
+++ public:
+++ // Keep these outlined to avoid dragging in macros from <cerrno>
+++
+++ ErrnoGuard();
+++ ~ErrnoGuard();
+++ private:
+++ int m_oldErrno;
+++ };
+++
+++}
+++
+++#endif // CATCH_ERRNO_GUARD_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+++#define CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+++
+++
+++#include <vector>
+++#include <string>
+++
+++namespace Catch {
+++
+++ class ExceptionTranslatorRegistry : public IExceptionTranslatorRegistry {
+++ public:
+++ ~ExceptionTranslatorRegistry() override;
+++ void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator );
+++ std::string translateActiveException() const override;
+++
+++ private:
+++ ExceptionTranslators m_translators;
+++ };
+++}
+++
+++#endif // CATCH_EXCEPTION_TRANSLATOR_REGISTRY_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
+++#define CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
+++
+++#include <cassert>
+++
+++namespace Catch {
+++
+++ /**
+++ * Wrapper for platform-specific fatal error (signals/SEH) handlers
+++ *
+++ * Tries to be cooperative with other handlers, and not step over
+++ * other handlers. This means that unknown structured exceptions
+++ * are passed on, previous signal handlers are called, and so on.
+++ *
+++ * Can only be instantiated once, and assumes that once a signal
+++ * is caught, the binary will end up terminating. Thus, there
+++ */
+++ class FatalConditionHandler {
+++ bool m_started = false;
+++
+++ // Install/disengage implementation for specific platform.
+++ // Should be if-defed to work on current platform, can assume
+++ // engage-disengage 1:1 pairing.
+++ void engage_platform();
+++ void disengage_platform() noexcept;
+++ public:
+++ // Should also have platform-specific implementations as needed
+++ FatalConditionHandler();
+++ ~FatalConditionHandler();
+++
+++ void engage() {
+++ assert(!m_started && "Handler cannot be installed twice.");
+++ m_started = true;
+++ engage_platform();
+++ }
+++
+++ void disengage() noexcept {
+++ assert(m_started && "Handler cannot be uninstalled without being installed first");
+++ m_started = false;
+++ disengage_platform();
+++ }
+++ };
+++
+++ //! Simple RAII guard for (dis)engaging the FatalConditionHandler
+++ class FatalConditionHandlerGuard {
+++ FatalConditionHandler* m_handler;
+++ public:
+++ FatalConditionHandlerGuard(FatalConditionHandler* handler):
+++ m_handler(handler) {
+++ m_handler->engage();
+++ }
+++ ~FatalConditionHandlerGuard() {
+++ m_handler->disengage();
+++ }
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_FATAL_CONDITION_HANDLER_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
+++#define CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
+++
+++
+++#include <cassert>
+++#include <cmath>
+++#include <cstdint>
+++#include <utility>
+++#include <limits>
+++
+++namespace Catch {
+++ namespace Detail {
+++
+++ uint32_t convertToBits(float f);
+++ uint64_t convertToBits(double d);
+++
+++ // Used when we know we want == comparison of two doubles
+++ // to centralize warning suppression
+++ bool directCompare( float lhs, float rhs );
+++ bool directCompare( double lhs, double rhs );
+++
+++ } // end namespace Detail
+++
+++
+++
+++#if defined( __GNUC__ ) || defined( __clang__ )
+++# pragma GCC diagnostic push
+++ // We do a bunch of direct compensations of floating point numbers,
+++ // because we know what we are doing and actually do want the direct
+++ // comparison behaviour.
+++# pragma GCC diagnostic ignored "-Wfloat-equal"
+++#endif
+++
+++ /**
+++ * Calculates the ULP distance between two floating point numbers
+++ *
+++ * The ULP distance of two floating point numbers is the count of
+++ * valid floating point numbers representable between them.
+++ *
+++ * There are some exceptions between how this function counts the
+++ * distance, and the interpretation of the standard as implemented.
+++ * by e.g. `nextafter`. For this function it always holds that:
+++ * * `(x == y) => ulpDistance(x, y) == 0` (so `ulpDistance(-0, 0) == 0`)
+++ * * `ulpDistance(maxFinite, INF) == 1`
+++ * * `ulpDistance(x, -x) == 2 * ulpDistance(x, 0)`
+++ *
+++ * \pre `!isnan( lhs )`
+++ * \pre `!isnan( rhs )`
+++ * \pre floating point numbers are represented in IEEE-754 format
+++ */
+++ template <typename FP>
+++ uint64_t ulpDistance( FP lhs, FP rhs ) {
+++ assert( std::numeric_limits<FP>::is_iec559 &&
+++ "ulpDistance assumes IEEE-754 format for floating point types" );
+++ assert( !Catch::isnan( lhs ) &&
+++ "Distance between NaN and number is not meaningful" );
+++ assert( !Catch::isnan( rhs ) &&
+++ "Distance between NaN and number is not meaningful" );
+++
+++ // We want X == Y to imply 0 ULP distance even if X and Y aren't
+++ // bit-equal (-0 and 0), or X - Y != 0 (same sign infinities).
+++ if ( lhs == rhs ) { return 0; }
+++
+++ // We need a properly typed positive zero for type inference.
+++ static constexpr FP positive_zero{};
+++
+++ // We want to ensure that +/- 0 is always represented as positive zero
+++ if ( lhs == positive_zero ) { lhs = positive_zero; }
+++ if ( rhs == positive_zero ) { rhs = positive_zero; }
+++
+++ // If arguments have different signs, we can handle them by summing
+++ // how far are they from 0 each.
+++ if ( std::signbit( lhs ) != std::signbit( rhs ) ) {
+++ return ulpDistance( std::abs( lhs ), positive_zero ) +
+++ ulpDistance( std::abs( rhs ), positive_zero );
+++ }
+++
+++ // When both lhs and rhs are of the same sign, we can just
+++ // read the numbers bitwise as integers, and then subtract them
+++ // (assuming IEEE).
+++ uint64_t lc = Detail::convertToBits( lhs );
+++ uint64_t rc = Detail::convertToBits( rhs );
+++
+++ // The ulp distance between two numbers is symmetric, so to avoid
+++ // dealing with overflows we want the bigger converted number on the lhs
+++ if ( lc < rc ) {
+++ std::swap( lc, rc );
+++ }
+++
+++ return lc - rc;
+++ }
+++
+++#if defined( __GNUC__ ) || defined( __clang__ )
+++# pragma GCC diagnostic pop
+++#endif
+++
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_FLOATING_POINT_HELPERS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_GETENV_HPP_INCLUDED
+++#define CATCH_GETENV_HPP_INCLUDED
+++
+++namespace Catch {
+++namespace Detail {
+++
+++ //! Wrapper over `std::getenv` that compiles on UWP (and always returns nullptr there)
+++ char const* getEnv(char const* varName);
+++
+++}
+++}
+++
+++#endif // CATCH_GETENV_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_IS_PERMUTATION_HPP_INCLUDED
+++#define CATCH_IS_PERMUTATION_HPP_INCLUDED
+++
+++#include <algorithm>
+++#include <iterator>
+++
+++namespace Catch {
+++ namespace Detail {
+++
+++ template <typename ForwardIter,
+++ typename Sentinel,
+++ typename T,
+++ typename Comparator>
+++ ForwardIter find_sentinel( ForwardIter start,
+++ Sentinel sentinel,
+++ T const& value,
+++ Comparator cmp ) {
+++ while ( start != sentinel ) {
+++ if ( cmp( *start, value ) ) { break; }
+++ ++start;
+++ }
+++ return start;
+++ }
+++
+++ template <typename ForwardIter,
+++ typename Sentinel,
+++ typename T,
+++ typename Comparator>
+++ std::ptrdiff_t count_sentinel( ForwardIter start,
+++ Sentinel sentinel,
+++ T const& value,
+++ Comparator cmp ) {
+++ std::ptrdiff_t count = 0;
+++ while ( start != sentinel ) {
+++ if ( cmp( *start, value ) ) { ++count; }
+++ ++start;
+++ }
+++ return count;
+++ }
+++
+++ template <typename ForwardIter, typename Sentinel>
+++ std::enable_if_t<!std::is_same<ForwardIter, Sentinel>::value,
+++ std::ptrdiff_t>
+++ sentinel_distance( ForwardIter iter, const Sentinel sentinel ) {
+++ std::ptrdiff_t dist = 0;
+++ while ( iter != sentinel ) {
+++ ++iter;
+++ ++dist;
+++ }
+++ return dist;
+++ }
+++
+++ template <typename ForwardIter>
+++ std::ptrdiff_t sentinel_distance( ForwardIter first,
+++ ForwardIter last ) {
+++ return std::distance( first, last );
+++ }
+++
+++ template <typename ForwardIter1,
+++ typename Sentinel1,
+++ typename ForwardIter2,
+++ typename Sentinel2,
+++ typename Comparator>
+++ bool check_element_counts( ForwardIter1 first_1,
+++ const Sentinel1 end_1,
+++ ForwardIter2 first_2,
+++ const Sentinel2 end_2,
+++ Comparator cmp ) {
+++ auto cursor = first_1;
+++ while ( cursor != end_1 ) {
+++ if ( find_sentinel( first_1, cursor, *cursor, cmp ) ==
+++ cursor ) {
+++ // we haven't checked this element yet
+++ const auto count_in_range_2 =
+++ count_sentinel( first_2, end_2, *cursor, cmp );
+++ // Not a single instance in 2nd range, so it cannot be a
+++ // permutation of 1st range
+++ if ( count_in_range_2 == 0 ) { return false; }
+++
+++ const auto count_in_range_1 =
+++ count_sentinel( cursor, end_1, *cursor, cmp );
+++ if ( count_in_range_1 != count_in_range_2 ) {
+++ return false;
+++ }
+++ }
+++
+++ ++cursor;
+++ }
+++
+++ return true;
+++ }
+++
+++ template <typename ForwardIter1,
+++ typename Sentinel1,
+++ typename ForwardIter2,
+++ typename Sentinel2,
+++ typename Comparator>
+++ bool is_permutation( ForwardIter1 first_1,
+++ const Sentinel1 end_1,
+++ ForwardIter2 first_2,
+++ const Sentinel2 end_2,
+++ Comparator cmp ) {
+++ // TODO: no optimization for stronger iterators, because we would also have to constrain on sentinel vs not sentinel types
+++ // TODO: Comparator has to be "both sides", e.g. a == b => b == a
+++ // This skips shared prefix of the two ranges
+++ while (first_1 != end_1 && first_2 != end_2 && cmp(*first_1, *first_2)) {
+++ ++first_1;
+++ ++first_2;
+++ }
+++
+++ // We need to handle case where at least one of the ranges has no more elements
+++ if (first_1 == end_1 || first_2 == end_2) {
+++ return first_1 == end_1 && first_2 == end_2;
+++ }
+++
+++ // pair counting is n**2, so we pay linear walk to compare the sizes first
+++ auto dist_1 = sentinel_distance( first_1, end_1 );
+++ auto dist_2 = sentinel_distance( first_2, end_2 );
+++
+++ if (dist_1 != dist_2) { return false; }
+++
+++ // Since we do not try to handle stronger iterators pair (e.g.
+++ // bidir) optimally, the only thing left to do is to check counts in
+++ // the remaining ranges.
+++ return check_element_counts( first_1, end_1, first_2, end_2, cmp );
+++ }
+++
+++ } // namespace Detail
+++} // namespace Catch
+++
+++#endif // CATCH_IS_PERMUTATION_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_ISTREAM_HPP_INCLUDED
+++#define CATCH_ISTREAM_HPP_INCLUDED
+++
+++
+++#include <iosfwd>
+++#include <cstddef>
+++#include <ostream>
+++#include <string>
+++
+++namespace Catch {
+++
+++ class IStream {
+++ public:
+++ virtual ~IStream(); // = default
+++ virtual std::ostream& stream() = 0;
+++ /**
+++ * Best guess on whether the instance is writing to a console (e.g. via stdout/stderr)
+++ *
+++ * This is useful for e.g. Win32 colour support, because the Win32
+++ * API manipulates console directly, unlike POSIX escape codes,
+++ * that can be written anywhere.
+++ *
+++ * Due to variety of ways to change where the stdout/stderr is
+++ * _actually_ being written, users should always assume that
+++ * the answer might be wrong.
+++ */
+++ virtual bool isConsole() const { return false; }
+++ };
+++
+++ /**
+++ * Creates a stream wrapper that writes to specific file.
+++ *
+++ * Also recognizes 4 special filenames
+++ * * `-` for stdout
+++ * * `%stdout` for stdout
+++ * * `%stderr` for stderr
+++ * * `%debug` for platform specific debugging output
+++ *
+++ * \throws if passed an unrecognized %-prefixed stream
+++ */
+++ auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream>;
+++
+++}
+++
+++#endif // CATCH_STREAM_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_JSONWRITER_HPP_INCLUDED
+++#define CATCH_JSONWRITER_HPP_INCLUDED
+++
+++
+++#include <cstdint>
+++#include <sstream>
+++
+++namespace Catch {
+++ class JsonObjectWriter;
+++ class JsonArrayWriter;
+++
+++ struct JsonUtils {
+++ static void indent( std::ostream& os, std::uint64_t level );
+++ static void appendCommaNewline( std::ostream& os,
+++ bool& should_comma,
+++ std::uint64_t level );
+++ };
+++
+++ class JsonValueWriter {
+++ public:
+++ JsonValueWriter( std::ostream& os );
+++ JsonValueWriter( std::ostream& os, std::uint64_t indent_level );
+++
+++ JsonObjectWriter writeObject() &&;
+++ JsonArrayWriter writeArray() &&;
+++
+++ template <typename T>
+++ void write( T const& value ) && {
+++ writeImpl( value, !std::is_arithmetic<T>::value );
+++ }
+++ void write( StringRef value ) &&;
+++ void write( bool value ) &&;
+++
+++ private:
+++ void writeImpl( StringRef value, bool quote );
+++
+++ // Without this SFINAE, this overload is a better match
+++ // for `std::string`, `char const*`, `char const[N]` args.
+++ // While it would still work, it would cause code bloat
+++ // and multiple iteration over the strings
+++ template <typename T,
+++ typename = typename std::enable_if_t<
+++ !std::is_convertible<T, StringRef>::value>>
+++ void writeImpl( T const& value, bool quote_value ) {
+++ m_sstream << value;
+++ writeImpl( m_sstream.str(), quote_value );
+++ }
+++
+++ std::ostream& m_os;
+++ std::stringstream m_sstream;
+++ std::uint64_t m_indent_level;
+++ };
+++
+++ class JsonObjectWriter {
+++ public:
+++ JsonObjectWriter( std::ostream& os );
+++ JsonObjectWriter( std::ostream& os, std::uint64_t indent_level );
+++
+++ JsonObjectWriter( JsonObjectWriter&& source ) noexcept;
+++ JsonObjectWriter& operator=( JsonObjectWriter&& source ) = delete;
+++
+++ ~JsonObjectWriter();
+++
+++ JsonValueWriter write( StringRef key );
+++
+++ private:
+++ std::ostream& m_os;
+++ std::uint64_t m_indent_level;
+++ bool m_should_comma = false;
+++ bool m_active = true;
+++ };
+++
+++ class JsonArrayWriter {
+++ public:
+++ JsonArrayWriter( std::ostream& os );
+++ JsonArrayWriter( std::ostream& os, std::uint64_t indent_level );
+++
+++ JsonArrayWriter( JsonArrayWriter&& source ) noexcept;
+++ JsonArrayWriter& operator=( JsonArrayWriter&& source ) = delete;
+++
+++ ~JsonArrayWriter();
+++
+++ JsonObjectWriter writeObject();
+++ JsonArrayWriter writeArray();
+++
+++ template <typename T>
+++ JsonArrayWriter& write( T const& value ) {
+++ return writeImpl( value );
+++ }
+++
+++ JsonArrayWriter& write( bool value );
+++
+++ private:
+++ template <typename T>
+++ JsonArrayWriter& writeImpl( T const& value ) {
+++ JsonUtils::appendCommaNewline(
+++ m_os, m_should_comma, m_indent_level + 1 );
+++ JsonValueWriter{ m_os }.write( value );
+++
+++ return *this;
+++ }
+++
+++ std::ostream& m_os;
+++ std::uint64_t m_indent_level;
+++ bool m_should_comma = false;
+++ bool m_active = true;
+++ };
+++
+++} // namespace Catch
+++
+++#endif // CATCH_JSONWRITER_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_LEAK_DETECTOR_HPP_INCLUDED
+++#define CATCH_LEAK_DETECTOR_HPP_INCLUDED
+++
+++namespace Catch {
+++
+++ struct LeakDetector {
+++ LeakDetector();
+++ ~LeakDetector();
+++ };
+++
+++}
+++#endif // CATCH_LEAK_DETECTOR_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_LIST_HPP_INCLUDED
+++#define CATCH_LIST_HPP_INCLUDED
+++
+++
+++#include <set>
+++#include <string>
+++
+++
+++namespace Catch {
+++
+++ class IEventListener;
+++ class Config;
+++
+++
+++ struct ReporterDescription {
+++ std::string name, description;
+++ };
+++ struct ListenerDescription {
+++ StringRef name;
+++ std::string description;
+++ };
+++
+++ struct TagInfo {
+++ void add(StringRef spelling);
+++ std::string all() const;
+++
+++ std::set<StringRef> spellings;
+++ std::size_t count = 0;
+++ };
+++
+++ bool list( IEventListener& reporter, Config const& config );
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_LIST_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
+++#define CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
+++
+++
+++#include <cstdio>
+++#include <iosfwd>
+++#include <string>
+++
+++namespace Catch {
+++
+++ class RedirectedStream {
+++ std::ostream& m_originalStream;
+++ std::ostream& m_redirectionStream;
+++ std::streambuf* m_prevBuf;
+++
+++ public:
+++ RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream );
+++ ~RedirectedStream();
+++ };
+++
+++ class RedirectedStdOut {
+++ ReusableStringStream m_rss;
+++ RedirectedStream m_cout;
+++ public:
+++ RedirectedStdOut();
+++ auto str() const -> std::string;
+++ };
+++
+++ // StdErr has two constituent streams in C++, std::cerr and std::clog
+++ // This means that we need to redirect 2 streams into 1 to keep proper
+++ // order of writes
+++ class RedirectedStdErr {
+++ ReusableStringStream m_rss;
+++ RedirectedStream m_cerr;
+++ RedirectedStream m_clog;
+++ public:
+++ RedirectedStdErr();
+++ auto str() const -> std::string;
+++ };
+++
+++ class RedirectedStreams {
+++ public:
+++ RedirectedStreams(RedirectedStreams const&) = delete;
+++ RedirectedStreams& operator=(RedirectedStreams const&) = delete;
+++ RedirectedStreams(RedirectedStreams&&) = delete;
+++ RedirectedStreams& operator=(RedirectedStreams&&) = delete;
+++
+++ RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr);
+++ ~RedirectedStreams();
+++ private:
+++ std::string& m_redirectedCout;
+++ std::string& m_redirectedCerr;
+++ RedirectedStdOut m_redirectedStdOut;
+++ RedirectedStdErr m_redirectedStdErr;
+++ };
+++
+++#if defined(CATCH_CONFIG_NEW_CAPTURE)
+++
+++ // Windows's implementation of std::tmpfile is terrible (it tries
+++ // to create a file inside system folder, thus requiring elevated
+++ // privileges for the binary), so we have to use tmpnam(_s) and
+++ // create the file ourselves there.
+++ class TempFile {
+++ public:
+++ TempFile(TempFile const&) = delete;
+++ TempFile& operator=(TempFile const&) = delete;
+++ TempFile(TempFile&&) = delete;
+++ TempFile& operator=(TempFile&&) = delete;
+++
+++ TempFile();
+++ ~TempFile();
+++
+++ std::FILE* getFile();
+++ std::string getContents();
+++
+++ private:
+++ std::FILE* m_file = nullptr;
+++ #if defined(_MSC_VER)
+++ char m_buffer[L_tmpnam] = { 0 };
+++ #endif
+++ };
+++
+++
+++ class OutputRedirect {
+++ public:
+++ OutputRedirect(OutputRedirect const&) = delete;
+++ OutputRedirect& operator=(OutputRedirect const&) = delete;
+++ OutputRedirect(OutputRedirect&&) = delete;
+++ OutputRedirect& operator=(OutputRedirect&&) = delete;
+++
+++
+++ OutputRedirect(std::string& stdout_dest, std::string& stderr_dest);
+++ ~OutputRedirect();
+++
+++ private:
+++ int m_originalStdout = -1;
+++ int m_originalStderr = -1;
+++ TempFile m_stdoutFile;
+++ TempFile m_stderrFile;
+++ std::string& m_stdoutDest;
+++ std::string& m_stderrDest;
+++ };
+++
+++#endif
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_OUTPUT_REDIRECT_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_PARSE_NUMBERS_HPP_INCLUDED
+++#define CATCH_PARSE_NUMBERS_HPP_INCLUDED
+++
+++
+++#include <string>
+++
+++namespace Catch {
+++
+++ /**
+++ * Parses unsigned int from the input, using provided base
+++ *
+++ * Effectively a wrapper around std::stoul but with better error checking
+++ * e.g. "-1" is rejected, instead of being parsed as UINT_MAX.
+++ */
+++ Optional<unsigned int> parseUInt(std::string const& input, int base = 10);
+++}
+++
+++#endif // CATCH_PARSE_NUMBERS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+++#define CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+++
+++
+++#include <map>
+++#include <string>
+++#include <vector>
+++
+++namespace Catch {
+++
+++ class IEventListener;
+++ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+++ class IReporterFactory;
+++ using IReporterFactoryPtr = Detail::unique_ptr<IReporterFactory>;
+++ struct ReporterConfig;
+++ class EventListenerFactory;
+++
+++ class ReporterRegistry {
+++ struct ReporterRegistryImpl;
+++ Detail::unique_ptr<ReporterRegistryImpl> m_impl;
+++
+++ public:
+++ ReporterRegistry();
+++ ~ReporterRegistry(); // = default;
+++
+++ IEventListenerPtr create( std::string const& name,
+++ ReporterConfig&& config ) const;
+++
+++ void registerReporter( std::string const& name,
+++ IReporterFactoryPtr factory );
+++
+++ void
+++ registerListener( Detail::unique_ptr<EventListenerFactory> factory );
+++
+++ std::map<std::string,
+++ IReporterFactoryPtr,
+++ Detail::CaseInsensitiveLess> const&
+++ getFactories() const;
+++
+++ std::vector<Detail::unique_ptr<EventListenerFactory>> const&
+++ getListeners() const;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_REPORTER_REGISTRY_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_RUN_CONTEXT_HPP_INCLUDED
+++#define CATCH_RUN_CONTEXT_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+++#define CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+++
+++
+++#include <string>
+++#include <vector>
+++
+++namespace Catch {
+++namespace TestCaseTracking {
+++
+++ struct NameAndLocation {
+++ std::string name;
+++ SourceLineInfo location;
+++
+++ NameAndLocation( std::string&& _name, SourceLineInfo const& _location );
+++ friend bool operator==(NameAndLocation const& lhs, NameAndLocation const& rhs) {
+++ // This is a very cheap check that should have a very high hit rate.
+++ // If we get to SourceLineInfo::operator==, we will redo it, but the
+++ // cost of repeating is trivial at that point (we will be paying
+++ // multiple strcmp/memcmps at that point).
+++ if ( lhs.location.line != rhs.location.line ) { return false; }
+++ return lhs.name == rhs.name && lhs.location == rhs.location;
+++ }
+++ friend bool operator!=(NameAndLocation const& lhs,
+++ NameAndLocation const& rhs) {
+++ return !( lhs == rhs );
+++ }
+++ };
+++
+++ /**
+++ * This is a variant of `NameAndLocation` that does not own the name string
+++ *
+++ * This avoids extra allocations when trying to locate a tracker by its
+++ * name and location, as long as we make sure that trackers only keep
+++ * around the owning variant.
+++ */
+++ struct NameAndLocationRef {
+++ StringRef name;
+++ SourceLineInfo location;
+++
+++ constexpr NameAndLocationRef( StringRef name_,
+++ SourceLineInfo location_ ):
+++ name( name_ ), location( location_ ) {}
+++
+++ friend bool operator==( NameAndLocation const& lhs,
+++ NameAndLocationRef const& rhs ) {
+++ // This is a very cheap check that should have a very high hit rate.
+++ // If we get to SourceLineInfo::operator==, we will redo it, but the
+++ // cost of repeating is trivial at that point (we will be paying
+++ // multiple strcmp/memcmps at that point).
+++ if ( lhs.location.line != rhs.location.line ) { return false; }
+++ return StringRef( lhs.name ) == rhs.name &&
+++ lhs.location == rhs.location;
+++ }
+++ friend bool operator==( NameAndLocationRef const& lhs,
+++ NameAndLocation const& rhs ) {
+++ return rhs == lhs;
+++ }
+++ };
+++
+++ class ITracker;
+++
+++ using ITrackerPtr = Catch::Detail::unique_ptr<ITracker>;
+++
+++ class ITracker {
+++ NameAndLocation m_nameAndLocation;
+++
+++ using Children = std::vector<ITrackerPtr>;
+++
+++ protected:
+++ enum CycleState {
+++ NotStarted,
+++ Executing,
+++ ExecutingChildren,
+++ NeedsAnotherRun,
+++ CompletedSuccessfully,
+++ Failed
+++ };
+++
+++ ITracker* m_parent = nullptr;
+++ Children m_children;
+++ CycleState m_runState = NotStarted;
+++
+++ public:
+++ ITracker( NameAndLocation&& nameAndLoc, ITracker* parent ):
+++ m_nameAndLocation( CATCH_MOVE(nameAndLoc) ),
+++ m_parent( parent )
+++ {}
+++
+++
+++ // static queries
+++ NameAndLocation const& nameAndLocation() const {
+++ return m_nameAndLocation;
+++ }
+++ ITracker* parent() const {
+++ return m_parent;
+++ }
+++
+++ virtual ~ITracker(); // = default
+++
+++
+++ // dynamic queries
+++
+++ //! Returns true if tracker run to completion (successfully or not)
+++ virtual bool isComplete() const = 0;
+++ //! Returns true if tracker run to completion successfully
+++ bool isSuccessfullyCompleted() const {
+++ return m_runState == CompletedSuccessfully;
+++ }
+++ //! Returns true if tracker has started but hasn't been completed
+++ bool isOpen() const;
+++ //! Returns true iff tracker has started
+++ bool hasStarted() const;
+++
+++ // actions
+++ virtual void close() = 0; // Successfully complete
+++ virtual void fail() = 0;
+++ void markAsNeedingAnotherRun();
+++
+++ //! Register a nested ITracker
+++ void addChild( ITrackerPtr&& child );
+++ /**
+++ * Returns ptr to specific child if register with this tracker.
+++ *
+++ * Returns nullptr if not found.
+++ */
+++ ITracker* findChild( NameAndLocationRef const& nameAndLocation );
+++ //! Have any children been added?
+++ bool hasChildren() const {
+++ return !m_children.empty();
+++ }
+++
+++
+++ //! Marks tracker as executing a child, doing se recursively up the tree
+++ void openChild();
+++
+++ /**
+++ * Returns true if the instance is a section tracker
+++ *
+++ * Subclasses should override to true if they are, replaces RTTI
+++ * for internal debug checks.
+++ */
+++ virtual bool isSectionTracker() const;
+++ /**
+++ * Returns true if the instance is a generator tracker
+++ *
+++ * Subclasses should override to true if they are, replaces RTTI
+++ * for internal debug checks.
+++ */
+++ virtual bool isGeneratorTracker() const;
+++ };
+++
+++ class TrackerContext {
+++
+++ enum RunState {
+++ NotStarted,
+++ Executing,
+++ CompletedCycle
+++ };
+++
+++ ITrackerPtr m_rootTracker;
+++ ITracker* m_currentTracker = nullptr;
+++ RunState m_runState = NotStarted;
+++
+++ public:
+++
+++ ITracker& startRun();
+++
+++ void startCycle() {
+++ m_currentTracker = m_rootTracker.get();
+++ m_runState = Executing;
+++ }
+++ void completeCycle();
+++
+++ bool completedCycle() const;
+++ ITracker& currentTracker() { return *m_currentTracker; }
+++ void setCurrentTracker( ITracker* tracker );
+++ };
+++
+++ class TrackerBase : public ITracker {
+++ protected:
+++
+++ TrackerContext& m_ctx;
+++
+++ public:
+++ TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+++
+++ bool isComplete() const override;
+++
+++ void open();
+++
+++ void close() override;
+++ void fail() override;
+++
+++ private:
+++ void moveToParent();
+++ void moveToThis();
+++ };
+++
+++ class SectionTracker : public TrackerBase {
+++ std::vector<StringRef> m_filters;
+++ // Note that lifetime-wise we piggy back off the name stored in the `ITracker` parent`.
+++ // Currently it allocates owns the name, so this is safe. If it is later refactored
+++ // to not own the name, the name still has to outlive the `ITracker` parent, so
+++ // this should still be safe.
+++ StringRef m_trimmed_name;
+++ public:
+++ SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent );
+++
+++ bool isSectionTracker() const override;
+++
+++ bool isComplete() const override;
+++
+++ static SectionTracker& acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation );
+++
+++ void tryOpen();
+++
+++ void addInitialFilters( std::vector<std::string> const& filters );
+++ void addNextFilters( std::vector<StringRef> const& filters );
+++ //! Returns filters active in this tracker
+++ std::vector<StringRef> const& getFilters() const { return m_filters; }
+++ //! Returns whitespace-trimmed name of the tracked section
+++ StringRef trimmedName() const;
+++ };
+++
+++} // namespace TestCaseTracking
+++
+++using TestCaseTracking::ITracker;
+++using TestCaseTracking::TrackerContext;
+++using TestCaseTracking::SectionTracker;
+++
+++} // namespace Catch
+++
+++#endif // CATCH_TEST_CASE_TRACKER_HPP_INCLUDED
+++
+++#include <string>
+++
+++namespace Catch {
+++
+++ class IGeneratorTracker;
+++ class IConfig;
+++ class IEventListener;
+++ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+++
+++ ///////////////////////////////////////////////////////////////////////////
+++
+++ class RunContext final : public IResultCapture {
+++
+++ public:
+++ RunContext( RunContext const& ) = delete;
+++ RunContext& operator =( RunContext const& ) = delete;
+++
+++ explicit RunContext( IConfig const* _config, IEventListenerPtr&& reporter );
+++
+++ ~RunContext() override;
+++
+++ Totals runTest(TestCaseHandle const& testCase);
+++
+++ public: // IResultCapture
+++
+++ // Assertion handlers
+++ void handleExpr
+++ ( AssertionInfo const& info,
+++ ITransientExpression const& expr,
+++ AssertionReaction& reaction ) override;
+++ void handleMessage
+++ ( AssertionInfo const& info,
+++ ResultWas::OfType resultType,
+++ StringRef message,
+++ AssertionReaction& reaction ) override;
+++ void handleUnexpectedExceptionNotThrown
+++ ( AssertionInfo const& info,
+++ AssertionReaction& reaction ) override;
+++ void handleUnexpectedInflightException
+++ ( AssertionInfo const& info,
+++ std::string&& message,
+++ AssertionReaction& reaction ) override;
+++ void handleIncomplete
+++ ( AssertionInfo const& info ) override;
+++ void handleNonExpr
+++ ( AssertionInfo const &info,
+++ ResultWas::OfType resultType,
+++ AssertionReaction &reaction ) override;
+++
+++ void notifyAssertionStarted( AssertionInfo const& info ) override;
+++ bool sectionStarted( StringRef sectionName,
+++ SourceLineInfo const& sectionLineInfo,
+++ Counts& assertions ) override;
+++
+++ void sectionEnded( SectionEndInfo&& endInfo ) override;
+++ void sectionEndedEarly( SectionEndInfo&& endInfo ) override;
+++
+++ IGeneratorTracker*
+++ acquireGeneratorTracker( StringRef generatorName,
+++ SourceLineInfo const& lineInfo ) override;
+++ IGeneratorTracker* createGeneratorTracker(
+++ StringRef generatorName,
+++ SourceLineInfo lineInfo,
+++ Generators::GeneratorBasePtr&& generator ) override;
+++
+++
+++ void benchmarkPreparing( StringRef name ) override;
+++ void benchmarkStarting( BenchmarkInfo const& info ) override;
+++ void benchmarkEnded( BenchmarkStats<> const& stats ) override;
+++ void benchmarkFailed( StringRef error ) override;
+++
+++ void pushScopedMessage( MessageInfo const& message ) override;
+++ void popScopedMessage( MessageInfo const& message ) override;
+++
+++ void emplaceUnscopedMessage( MessageBuilder&& builder ) override;
+++
+++ std::string getCurrentTestName() const override;
+++
+++ const AssertionResult* getLastResult() const override;
+++
+++ void exceptionEarlyReported() override;
+++
+++ void handleFatalErrorCondition( StringRef message ) override;
+++
+++ bool lastAssertionPassed() override;
+++
+++ void assertionPassed() override;
+++
+++ public:
+++ // !TBD We need to do this another way!
+++ bool aborting() const;
+++
+++ private:
+++
+++ void runCurrentTest( std::string& redirectedCout, std::string& redirectedCerr );
+++ void invokeActiveTestCase();
+++
+++ void resetAssertionInfo();
+++ bool testForMissingAssertions( Counts& assertions );
+++
+++ void assertionEnded( AssertionResult&& result );
+++ void reportExpr
+++ ( AssertionInfo const &info,
+++ ResultWas::OfType resultType,
+++ ITransientExpression const *expr,
+++ bool negated );
+++
+++ void populateReaction( AssertionReaction& reaction );
+++
+++ private:
+++
+++ void handleUnfinishedSections();
+++
+++ TestRunInfo m_runInfo;
+++ TestCaseHandle const* m_activeTestCase = nullptr;
+++ ITracker* m_testCaseTracker = nullptr;
+++ Optional<AssertionResult> m_lastResult;
+++
+++ IConfig const* m_config;
+++ Totals m_totals;
+++ IEventListenerPtr m_reporter;
+++ std::vector<MessageInfo> m_messages;
+++ std::vector<ScopedMessage> m_messageScopes; /* Keeps owners of so-called unscoped messages. */
+++ AssertionInfo m_lastAssertionInfo;
+++ std::vector<SectionEndInfo> m_unfinishedSections;
+++ std::vector<ITracker*> m_activeSections;
+++ TrackerContext m_trackerContext;
+++ FatalConditionHandler m_fatalConditionhandler;
+++ bool m_lastAssertionPassed = false;
+++ bool m_shouldReportUnexpected = true;
+++ bool m_includeSuccessfulResults;
+++ };
+++
+++ void seedRng(IConfig const& config);
+++ unsigned int rngSeed();
+++} // end namespace Catch
+++
+++#endif // CATCH_RUN_CONTEXT_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_SHARDING_HPP_INCLUDED
+++#define CATCH_SHARDING_HPP_INCLUDED
+++
+++#include <cassert>
+++#include <cmath>
+++#include <algorithm>
+++
+++namespace Catch {
+++
+++ template<typename Container>
+++ Container createShard(Container const& container, std::size_t const shardCount, std::size_t const shardIndex) {
+++ assert(shardCount > shardIndex);
+++
+++ if (shardCount == 1) {
+++ return container;
+++ }
+++
+++ const std::size_t totalTestCount = container.size();
+++
+++ const std::size_t shardSize = totalTestCount / shardCount;
+++ const std::size_t leftoverTests = totalTestCount % shardCount;
+++
+++ const std::size_t startIndex = shardIndex * shardSize + (std::min)(shardIndex, leftoverTests);
+++ const std::size_t endIndex = (shardIndex + 1) * shardSize + (std::min)(shardIndex + 1, leftoverTests);
+++
+++ auto startIterator = std::next(container.begin(), static_cast<std::ptrdiff_t>(startIndex));
+++ auto endIterator = std::next(container.begin(), static_cast<std::ptrdiff_t>(endIndex));
+++
+++ return Container(startIterator, endIterator);
+++ }
+++
+++}
+++
+++#endif // CATCH_SHARDING_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_SINGLETONS_HPP_INCLUDED
+++#define CATCH_SINGLETONS_HPP_INCLUDED
+++
+++namespace Catch {
+++
+++ struct ISingleton {
+++ virtual ~ISingleton(); // = default
+++ };
+++
+++
+++ void addSingleton( ISingleton* singleton );
+++ void cleanupSingletons();
+++
+++
+++ template<typename SingletonImplT, typename InterfaceT = SingletonImplT, typename MutableInterfaceT = InterfaceT>
+++ class Singleton : SingletonImplT, public ISingleton {
+++
+++ static auto getInternal() -> Singleton* {
+++ static Singleton* s_instance = nullptr;
+++ if( !s_instance ) {
+++ s_instance = new Singleton;
+++ addSingleton( s_instance );
+++ }
+++ return s_instance;
+++ }
+++
+++ public:
+++ static auto get() -> InterfaceT const& {
+++ return *getInternal();
+++ }
+++ static auto getMutable() -> MutableInterfaceT& {
+++ return *getInternal();
+++ }
+++ };
+++
+++} // namespace Catch
+++
+++#endif // CATCH_SINGLETONS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
+++#define CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
+++
+++
+++#include <vector>
+++#include <exception>
+++
+++namespace Catch {
+++
+++ class StartupExceptionRegistry {
+++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+++ public:
+++ void add(std::exception_ptr const& exception) noexcept;
+++ std::vector<std::exception_ptr> const& getExceptions() const noexcept;
+++ private:
+++ std::vector<std::exception_ptr> m_exceptions;
+++#endif
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_STARTUP_EXCEPTION_REGISTRY_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_STDSTREAMS_HPP_INCLUDED
+++#define CATCH_STDSTREAMS_HPP_INCLUDED
+++
+++#include <iosfwd>
+++
+++namespace Catch {
+++
+++ std::ostream& cout();
+++ std::ostream& cerr();
+++ std::ostream& clog();
+++
+++} // namespace Catch
+++
+++#endif
+++
+++
+++#ifndef CATCH_STRING_MANIP_HPP_INCLUDED
+++#define CATCH_STRING_MANIP_HPP_INCLUDED
+++
+++
+++#include <cstdint>
+++#include <string>
+++#include <iosfwd>
+++#include <vector>
+++
+++namespace Catch {
+++
+++ bool startsWith( std::string const& s, std::string const& prefix );
+++ bool startsWith( StringRef s, char prefix );
+++ bool endsWith( std::string const& s, std::string const& suffix );
+++ bool endsWith( std::string const& s, char suffix );
+++ bool contains( std::string const& s, std::string const& infix );
+++ void toLowerInPlace( std::string& s );
+++ std::string toLower( std::string const& s );
+++ char toLower( char c );
+++ //! Returns a new string without whitespace at the start/end
+++ std::string trim( std::string const& str );
+++ //! Returns a substring of the original ref without whitespace. Beware lifetimes!
+++ StringRef trim(StringRef ref);
+++
+++ // !!! Be aware, returns refs into original string - make sure original string outlives them
+++ std::vector<StringRef> splitStringRef( StringRef str, char delimiter );
+++ bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis );
+++
+++ /**
+++ * Helper for streaming a "count [maybe-plural-of-label]" human-friendly string
+++ *
+++ * Usage example:
+++ * ```cpp
+++ * std::cout << "Found " << pluralise(count, "error") << '\n';
+++ * ```
+++ *
+++ * **Important:** The provided string must outlive the instance
+++ */
+++ class pluralise {
+++ std::uint64_t m_count;
+++ StringRef m_label;
+++
+++ public:
+++ constexpr pluralise(std::uint64_t count, StringRef label):
+++ m_count(count),
+++ m_label(label)
+++ {}
+++
+++ friend std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser );
+++ };
+++}
+++
+++#endif // CATCH_STRING_MANIP_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+++#define CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+++
+++
+++#include <map>
+++#include <string>
+++
+++namespace Catch {
+++ struct SourceLineInfo;
+++
+++ class TagAliasRegistry : public ITagAliasRegistry {
+++ public:
+++ ~TagAliasRegistry() override;
+++ TagAlias const* find( std::string const& alias ) const override;
+++ std::string expandAliases( std::string const& unexpandedTestSpec ) const override;
+++ void add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo );
+++
+++ private:
+++ std::map<std::string, TagAlias> m_registry;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_TAG_ALIAS_REGISTRY_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED
+++#define CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED
+++
+++#include <cstdint>
+++
+++namespace Catch {
+++
+++ struct TestCaseInfo;
+++
+++ class TestCaseInfoHasher {
+++ public:
+++ using hash_t = std::uint64_t;
+++ TestCaseInfoHasher( hash_t seed );
+++ uint32_t operator()( TestCaseInfo const& t ) const;
+++
+++ private:
+++ hash_t m_seed;
+++ };
+++
+++} // namespace Catch
+++
+++#endif /* CATCH_TEST_CASE_INFO_HASHER_HPP_INCLUDED */
+++
+++
+++#ifndef CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+++#define CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+++
+++
+++#include <vector>
+++
+++namespace Catch {
+++
+++ class IConfig;
+++ class ITestInvoker;
+++ class TestCaseHandle;
+++ class TestSpec;
+++
+++ std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases );
+++
+++ bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config );
+++
+++ std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config );
+++ std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config );
+++
+++ class TestRegistry : public ITestCaseRegistry {
+++ public:
+++ void registerTest( Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker );
+++
+++ std::vector<TestCaseInfo*> const& getAllInfos() const override;
+++ std::vector<TestCaseHandle> const& getAllTests() const override;
+++ std::vector<TestCaseHandle> const& getAllTestsSorted( IConfig const& config ) const override;
+++
+++ ~TestRegistry() override; // = default
+++
+++ private:
+++ std::vector<Detail::unique_ptr<TestCaseInfo>> m_owned_test_infos;
+++ // Keeps a materialized vector for `getAllInfos`.
+++ // We should get rid of that eventually (see interface note)
+++ std::vector<TestCaseInfo*> m_viewed_test_infos;
+++
+++ std::vector<Detail::unique_ptr<ITestInvoker>> m_invokers;
+++ std::vector<TestCaseHandle> m_handles;
+++ mutable TestRunOrder m_currentSortOrder = TestRunOrder::Declared;
+++ mutable std::vector<TestCaseHandle> m_sortedFunctions;
+++ };
+++
+++ ///////////////////////////////////////////////////////////////////////////
+++
+++
+++} // end namespace Catch
+++
+++
+++#endif // CATCH_TEST_CASE_REGISTRY_IMPL_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+++#define CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+++
+++#ifdef __clang__
+++#pragma clang diagnostic push
+++#pragma clang diagnostic ignored "-Wpadded"
+++#endif
+++
+++
+++#include <vector>
+++#include <string>
+++
+++namespace Catch {
+++
+++ class ITagAliasRegistry;
+++
+++ class TestSpecParser {
+++ enum Mode{ None, Name, QuotedName, Tag, EscapedName };
+++ Mode m_mode = None;
+++ Mode lastMode = None;
+++ bool m_exclusion = false;
+++ std::size_t m_pos = 0;
+++ std::size_t m_realPatternPos = 0;
+++ std::string m_arg;
+++ std::string m_substring;
+++ std::string m_patternName;
+++ std::vector<std::size_t> m_escapeChars;
+++ TestSpec::Filter m_currentFilter;
+++ TestSpec m_testSpec;
+++ ITagAliasRegistry const* m_tagAliases = nullptr;
+++
+++ public:
+++ TestSpecParser( ITagAliasRegistry const& tagAliases );
+++
+++ TestSpecParser& parse( std::string const& arg );
+++ TestSpec testSpec();
+++
+++ private:
+++ bool visitChar( char c );
+++ void startNewMode( Mode mode );
+++ bool processNoneChar( char c );
+++ void processNameChar( char c );
+++ bool processOtherChar( char c );
+++ void endMode();
+++ void escape();
+++ bool isControlChar( char c ) const;
+++ void saveLastMode();
+++ void revertBackToLastMode();
+++ void addFilter();
+++ bool separate();
+++
+++ // Handles common preprocessing of the pattern for name/tag patterns
+++ std::string preprocessPattern();
+++ // Adds the current pattern as a test name
+++ void addNamePattern();
+++ // Adds the current pattern as a tag
+++ void addTagPattern();
+++
+++ inline void addCharToPattern(char c) {
+++ m_substring += c;
+++ m_patternName += c;
+++ m_realPatternPos++;
+++ }
+++
+++ };
+++
+++} // namespace Catch
+++
+++#ifdef __clang__
+++#pragma clang diagnostic pop
+++#endif
+++
+++#endif // CATCH_TEST_SPEC_PARSER_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_TEXTFLOW_HPP_INCLUDED
+++#define CATCH_TEXTFLOW_HPP_INCLUDED
+++
+++
+++#include <cassert>
+++#include <string>
+++#include <vector>
+++
+++namespace Catch {
+++ namespace TextFlow {
+++
+++ class Columns;
+++
+++ /**
+++ * Abstraction for a string with ansi escape sequences that
+++ * automatically skips over escapes when iterating. Only graphical
+++ * escape sequences are considered.
+++ *
+++ * Internal representation:
+++ * An escape sequence looks like \033[39;49m
+++ * We need bidirectional iteration and the unbound length of escape
+++ * sequences poses a problem for operator-- To make this work we'll
+++ * replace the last `m` with a 0xff (this is a codepoint that won't have
+++ * any utf-8 meaning).
+++ */
+++ class AnsiSkippingString {
+++ std::string m_string;
+++ std::size_t m_size = 0;
+++
+++ // perform 0xff replacement and calculate m_size
+++ void preprocessString();
+++
+++ public:
+++ class const_iterator;
+++ using iterator = const_iterator;
+++ // note: must be u-suffixed or this will cause a "truncation of
+++ // constant value" warning on MSVC
+++ static constexpr char sentinel = static_cast<char>( 0xffu );
+++
+++ explicit AnsiSkippingString( std::string const& text );
+++ explicit AnsiSkippingString( std::string&& text );
+++
+++ const_iterator begin() const;
+++ const_iterator end() const;
+++
+++ size_t size() const { return m_size; }
+++
+++ std::string substring( const_iterator begin,
+++ const_iterator end ) const;
+++ };
+++
+++ class AnsiSkippingString::const_iterator {
+++ friend AnsiSkippingString;
+++ struct EndTag {};
+++
+++ const std::string* m_string;
+++ std::string::const_iterator m_it;
+++
+++ explicit const_iterator( const std::string& string, EndTag ):
+++ m_string( &string ), m_it( string.end() ) {}
+++
+++ void tryParseAnsiEscapes();
+++ void advance();
+++ void unadvance();
+++
+++ public:
+++ using difference_type = std::ptrdiff_t;
+++ using value_type = char;
+++ using pointer = value_type*;
+++ using reference = value_type&;
+++ using iterator_category = std::bidirectional_iterator_tag;
+++
+++ explicit const_iterator( const std::string& string ):
+++ m_string( &string ), m_it( string.begin() ) {
+++ tryParseAnsiEscapes();
+++ }
+++
+++ char operator*() const { return *m_it; }
+++
+++ const_iterator& operator++() {
+++ advance();
+++ return *this;
+++ }
+++ const_iterator operator++( int ) {
+++ iterator prev( *this );
+++ operator++();
+++ return prev;
+++ }
+++ const_iterator& operator--() {
+++ unadvance();
+++ return *this;
+++ }
+++ const_iterator operator--( int ) {
+++ iterator prev( *this );
+++ operator--();
+++ return prev;
+++ }
+++
+++ bool operator==( const_iterator const& other ) const {
+++ return m_it == other.m_it;
+++ }
+++ bool operator!=( const_iterator const& other ) const {
+++ return !operator==( other );
+++ }
+++ bool operator<=( const_iterator const& other ) const {
+++ return m_it <= other.m_it;
+++ }
+++
+++ const_iterator oneBefore() const {
+++ auto it = *this;
+++ return --it;
+++ }
+++ };
+++
+++ /**
+++ * Represents a column of text with specific width and indentation
+++ *
+++ * When written out to a stream, it will perform linebreaking
+++ * of the provided text so that the written lines fit within
+++ * target width.
+++ */
+++ class Column {
+++ // String to be written out
+++ AnsiSkippingString m_string;
+++ // Width of the column for linebreaking
+++ size_t m_width = CATCH_CONFIG_CONSOLE_WIDTH - 1;
+++ // Indentation of other lines (including first if initial indent is
+++ // unset)
+++ size_t m_indent = 0;
+++ // Indentation of the first line
+++ size_t m_initialIndent = std::string::npos;
+++
+++ public:
+++ /**
+++ * Iterates "lines" in `Column` and returns them
+++ */
+++ class const_iterator {
+++ friend Column;
+++ struct EndTag {};
+++
+++ Column const& m_column;
+++ // Where does the current line start?
+++ AnsiSkippingString::const_iterator m_lineStart;
+++ // How long should the current line be?
+++ AnsiSkippingString::const_iterator m_lineEnd;
+++ // How far have we checked the string to iterate?
+++ AnsiSkippingString::const_iterator m_parsedTo;
+++ // Should a '-' be appended to the line?
+++ bool m_addHyphen = false;
+++
+++ const_iterator( Column const& column, EndTag ):
+++ m_column( column ),
+++ m_lineStart( m_column.m_string.end() ),
+++ m_lineEnd( column.m_string.end() ),
+++ m_parsedTo( column.m_string.end() ) {}
+++
+++ // Calculates the length of the current line
+++ void calcLength();
+++
+++ // Returns current indentation width
+++ size_t indentSize() const;
+++
+++ // Creates an indented and (optionally) suffixed string from
+++ // current iterator position, indentation and length.
+++ std::string addIndentAndSuffix(
+++ AnsiSkippingString::const_iterator start,
+++ AnsiSkippingString::const_iterator end ) const;
+++
+++ public:
+++ using difference_type = std::ptrdiff_t;
+++ using value_type = std::string;
+++ using pointer = value_type*;
+++ using reference = value_type&;
+++ using iterator_category = std::forward_iterator_tag;
+++
+++ explicit const_iterator( Column const& column );
+++
+++ std::string operator*() const;
+++
+++ const_iterator& operator++();
+++ const_iterator operator++( int );
+++
+++ bool operator==( const_iterator const& other ) const {
+++ return m_lineStart == other.m_lineStart &&
+++ &m_column == &other.m_column;
+++ }
+++ bool operator!=( const_iterator const& other ) const {
+++ return !operator==( other );
+++ }
+++ };
+++ using iterator = const_iterator;
+++
+++ explicit Column( std::string const& text ): m_string( text ) {}
+++ explicit Column( std::string&& text ):
+++ m_string( CATCH_MOVE( text ) ) {}
+++
+++ Column& width( size_t newWidth ) & {
+++ assert( newWidth > 0 );
+++ m_width = newWidth;
+++ return *this;
+++ }
+++ Column&& width( size_t newWidth ) && {
+++ assert( newWidth > 0 );
+++ m_width = newWidth;
+++ return CATCH_MOVE( *this );
+++ }
+++ Column& indent( size_t newIndent ) & {
+++ m_indent = newIndent;
+++ return *this;
+++ }
+++ Column&& indent( size_t newIndent ) && {
+++ m_indent = newIndent;
+++ return CATCH_MOVE( *this );
+++ }
+++ Column& initialIndent( size_t newIndent ) & {
+++ m_initialIndent = newIndent;
+++ return *this;
+++ }
+++ Column&& initialIndent( size_t newIndent ) && {
+++ m_initialIndent = newIndent;
+++ return CATCH_MOVE( *this );
+++ }
+++
+++ size_t width() const { return m_width; }
+++ const_iterator begin() const { return const_iterator( *this ); }
+++ const_iterator end() const {
+++ return { *this, const_iterator::EndTag{} };
+++ }
+++
+++ friend std::ostream& operator<<( std::ostream& os,
+++ Column const& col );
+++
+++ friend Columns operator+( Column const& lhs, Column const& rhs );
+++ friend Columns operator+( Column&& lhs, Column&& rhs );
+++ };
+++
+++ //! Creates a column that serves as an empty space of specific width
+++ Column Spacer( size_t spaceWidth );
+++
+++ class Columns {
+++ std::vector<Column> m_columns;
+++
+++ public:
+++ class iterator {
+++ friend Columns;
+++ struct EndTag {};
+++
+++ std::vector<Column> const& m_columns;
+++ std::vector<Column::const_iterator> m_iterators;
+++ size_t m_activeIterators;
+++
+++ iterator( Columns const& columns, EndTag );
+++
+++ public:
+++ using difference_type = std::ptrdiff_t;
+++ using value_type = std::string;
+++ using pointer = value_type*;
+++ using reference = value_type&;
+++ using iterator_category = std::forward_iterator_tag;
+++
+++ explicit iterator( Columns const& columns );
+++
+++ auto operator==( iterator const& other ) const -> bool {
+++ return m_iterators == other.m_iterators;
+++ }
+++ auto operator!=( iterator const& other ) const -> bool {
+++ return m_iterators != other.m_iterators;
+++ }
+++ std::string operator*() const;
+++ iterator& operator++();
+++ iterator operator++( int );
+++ };
+++ using const_iterator = iterator;
+++
+++ iterator begin() const { return iterator( *this ); }
+++ iterator end() const { return { *this, iterator::EndTag() }; }
+++
+++ friend Columns& operator+=( Columns& lhs, Column const& rhs );
+++ friend Columns& operator+=( Columns& lhs, Column&& rhs );
+++ friend Columns operator+( Columns const& lhs, Column const& rhs );
+++ friend Columns operator+( Columns&& lhs, Column&& rhs );
+++
+++ friend std::ostream& operator<<( std::ostream& os,
+++ Columns const& cols );
+++ };
+++
+++ } // namespace TextFlow
+++} // namespace Catch
+++#endif // CATCH_TEXTFLOW_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_TO_STRING_HPP_INCLUDED
+++#define CATCH_TO_STRING_HPP_INCLUDED
+++
+++#include <string>
+++
+++
+++namespace Catch {
+++ template <typename T>
+++ std::string to_string(T const& t) {
+++#if defined(CATCH_CONFIG_CPP11_TO_STRING)
+++ return std::to_string(t);
+++#else
+++ ReusableStringStream rss;
+++ rss << t;
+++ return rss.str();
+++#endif
+++ }
+++} // end namespace Catch
+++
+++#endif // CATCH_TO_STRING_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+++#define CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+++
+++namespace Catch {
+++ bool uncaught_exceptions();
+++} // end namespace Catch
+++
+++#endif // CATCH_UNCAUGHT_EXCEPTIONS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_XMLWRITER_HPP_INCLUDED
+++#define CATCH_XMLWRITER_HPP_INCLUDED
+++
+++
+++#include <iosfwd>
+++#include <vector>
+++
+++namespace Catch {
+++ enum class XmlFormatting {
+++ None = 0x00,
+++ Indent = 0x01,
+++ Newline = 0x02,
+++ };
+++
+++ XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs);
+++ XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs);
+++
+++ /**
+++ * Helper for XML-encoding text (escaping angle brackets, quotes, etc)
+++ *
+++ * Note: doesn't take ownership of passed strings, and thus the
+++ * encoded string must outlive the encoding instance.
+++ */
+++ class XmlEncode {
+++ public:
+++ enum ForWhat { ForTextNodes, ForAttributes };
+++
+++ XmlEncode( StringRef str, ForWhat forWhat = ForTextNodes );
+++
+++ void encodeTo( std::ostream& os ) const;
+++
+++ friend std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode );
+++
+++ private:
+++ StringRef m_str;
+++ ForWhat m_forWhat;
+++ };
+++
+++ class XmlWriter {
+++ public:
+++
+++ class ScopedElement {
+++ public:
+++ ScopedElement( XmlWriter* writer, XmlFormatting fmt );
+++
+++ ScopedElement( ScopedElement&& other ) noexcept;
+++ ScopedElement& operator=( ScopedElement&& other ) noexcept;
+++
+++ ~ScopedElement();
+++
+++ ScopedElement&
+++ writeText( StringRef text,
+++ XmlFormatting fmt = XmlFormatting::Newline |
+++ XmlFormatting::Indent );
+++
+++ ScopedElement& writeAttribute( StringRef name,
+++ StringRef attribute );
+++ template <typename T,
+++ // Without this SFINAE, this overload is a better match
+++ // for `std::string`, `char const*`, `char const[N]` args.
+++ // While it would still work, it would cause code bloat
+++ // and multiple iteration over the strings
+++ typename = typename std::enable_if_t<
+++ !std::is_convertible<T, StringRef>::value>>
+++ ScopedElement& writeAttribute( StringRef name,
+++ T const& attribute ) {
+++ m_writer->writeAttribute( name, attribute );
+++ return *this;
+++ }
+++
+++ private:
+++ XmlWriter* m_writer = nullptr;
+++ XmlFormatting m_fmt;
+++ };
+++
+++ XmlWriter( std::ostream& os );
+++ ~XmlWriter();
+++
+++ XmlWriter( XmlWriter const& ) = delete;
+++ XmlWriter& operator=( XmlWriter const& ) = delete;
+++
+++ XmlWriter& startElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+++
+++ ScopedElement scopedElement( std::string const& name, XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+++
+++ XmlWriter& endElement(XmlFormatting fmt = XmlFormatting::Newline | XmlFormatting::Indent);
+++
+++ //! The attribute content is XML-encoded
+++ XmlWriter& writeAttribute( StringRef name, StringRef attribute );
+++
+++ //! Writes the attribute as "true/false"
+++ XmlWriter& writeAttribute( StringRef name, bool attribute );
+++
+++ //! The attribute content is XML-encoded
+++ XmlWriter& writeAttribute( StringRef name, char const* attribute );
+++
+++ //! The attribute value must provide op<<(ostream&, T). The resulting
+++ //! serialization is XML-encoded
+++ template <typename T,
+++ // Without this SFINAE, this overload is a better match
+++ // for `std::string`, `char const*`, `char const[N]` args.
+++ // While it would still work, it would cause code bloat
+++ // and multiple iteration over the strings
+++ typename = typename std::enable_if_t<
+++ !std::is_convertible<T, StringRef>::value>>
+++ XmlWriter& writeAttribute( StringRef name, T const& attribute ) {
+++ ReusableStringStream rss;
+++ rss << attribute;
+++ return writeAttribute( name, rss.str() );
+++ }
+++
+++ //! Writes escaped `text` in a element
+++ XmlWriter& writeText( StringRef text,
+++ XmlFormatting fmt = XmlFormatting::Newline |
+++ XmlFormatting::Indent );
+++
+++ //! Writes XML comment as "<!-- text -->"
+++ XmlWriter& writeComment( StringRef text,
+++ XmlFormatting fmt = XmlFormatting::Newline |
+++ XmlFormatting::Indent );
+++
+++ void writeStylesheetRef( StringRef url );
+++
+++ void ensureTagClosed();
+++
+++ private:
+++
+++ void applyFormatting(XmlFormatting fmt);
+++
+++ void writeDeclaration();
+++
+++ void newlineIfNecessary();
+++
+++ bool m_tagIsOpen = false;
+++ bool m_needsNewline = false;
+++ std::vector<std::string> m_tags;
+++ std::string m_indent;
+++ std::ostream& m_os;
+++ };
+++
+++}
+++
+++#endif // CATCH_XMLWRITER_HPP_INCLUDED
+++
+++
+++/** \file
+++ * This is a convenience header for Catch2's Matcher support. It includes
+++ * **all** of Catch2 headers related to matchers.
+++ *
+++ * Generally the Catch2 users should use specific includes they need,
+++ * but this header can be used instead for ease-of-experimentation, or
+++ * just plain convenience, at the cost of increased compilation times.
+++ *
+++ * When a new header is added to either the `matchers` folder, or to
+++ * the corresponding internal subfolder, it should be added here.
+++ */
+++
+++#ifndef CATCH_MATCHERS_ALL_HPP_INCLUDED
+++#define CATCH_MATCHERS_ALL_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_MATCHERS_HPP_INCLUDED
+++#define CATCH_MATCHERS_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_MATCHERS_IMPL_HPP_INCLUDED
+++#define CATCH_MATCHERS_IMPL_HPP_INCLUDED
+++
+++
+++#include <string>
+++
+++namespace Catch {
+++
+++#ifdef __clang__
+++# pragma clang diagnostic push
+++# pragma clang diagnostic ignored "-Wsign-compare"
+++# pragma clang diagnostic ignored "-Wnon-virtual-dtor"
+++#elif defined __GNUC__
+++# pragma GCC diagnostic push
+++# pragma GCC diagnostic ignored "-Wsign-compare"
+++# pragma GCC diagnostic ignored "-Wnon-virtual-dtor"
+++#endif
+++
+++ template<typename ArgT, typename MatcherT>
+++ class MatchExpr : public ITransientExpression {
+++ ArgT && m_arg;
+++ MatcherT const& m_matcher;
+++ public:
+++ MatchExpr( ArgT && arg, MatcherT const& matcher )
+++ : ITransientExpression{ true, matcher.match( arg ) }, // not forwarding arg here on purpose
+++ m_arg( CATCH_FORWARD(arg) ),
+++ m_matcher( matcher )
+++ {}
+++
+++ void streamReconstructedExpression( std::ostream& os ) const override {
+++ os << Catch::Detail::stringify( m_arg )
+++ << ' '
+++ << m_matcher.toString();
+++ }
+++ };
+++
+++#ifdef __clang__
+++# pragma clang diagnostic pop
+++#elif defined __GNUC__
+++# pragma GCC diagnostic pop
+++#endif
+++
+++
+++ namespace Matchers {
+++ template <typename ArgT>
+++ class MatcherBase;
+++ }
+++
+++ using StringMatcher = Matchers::MatcherBase<std::string>;
+++
+++ void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher );
+++
+++ template<typename ArgT, typename MatcherT>
+++ auto makeMatchExpr( ArgT && arg, MatcherT const& matcher ) -> MatchExpr<ArgT, MatcherT> {
+++ return MatchExpr<ArgT, MatcherT>( CATCH_FORWARD(arg), matcher );
+++ }
+++
+++} // namespace Catch
+++
+++
+++///////////////////////////////////////////////////////////////////////////////
+++#define INTERNAL_CHECK_THAT( macroName, matcher, resultDisposition, arg ) \
+++ do { \
+++ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(arg) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+++ INTERNAL_CATCH_TRY { \
+++ catchAssertionHandler.handleExpr( Catch::makeMatchExpr( arg, matcher ) ); \
+++ } INTERNAL_CATCH_CATCH( catchAssertionHandler ) \
+++ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+++ } while( false )
+++
+++
+++///////////////////////////////////////////////////////////////////////////////
+++#define INTERNAL_CATCH_THROWS_MATCHES( macroName, exceptionType, resultDisposition, matcher, ... ) \
+++ do { \
+++ Catch::AssertionHandler catchAssertionHandler( macroName##_catch_sr, CATCH_INTERNAL_LINEINFO, CATCH_INTERNAL_STRINGIFY(__VA_ARGS__) ", " CATCH_INTERNAL_STRINGIFY(exceptionType) ", " CATCH_INTERNAL_STRINGIFY(matcher), resultDisposition ); \
+++ if( catchAssertionHandler.allowThrows() ) \
+++ try { \
+++ static_cast<void>(__VA_ARGS__ ); \
+++ catchAssertionHandler.handleUnexpectedExceptionNotThrown(); \
+++ } \
+++ catch( exceptionType const& ex ) { \
+++ catchAssertionHandler.handleExpr( Catch::makeMatchExpr( ex, matcher ) ); \
+++ } \
+++ catch( ... ) { \
+++ catchAssertionHandler.handleUnexpectedInflightException(); \
+++ } \
+++ else \
+++ catchAssertionHandler.handleThrowingCallSkipped(); \
+++ INTERNAL_CATCH_REACT( catchAssertionHandler ) \
+++ } while( false )
+++
+++
+++#endif // CATCH_MATCHERS_IMPL_HPP_INCLUDED
+++
+++#include <string>
+++#include <vector>
+++
+++namespace Catch {
+++namespace Matchers {
+++
+++ class MatcherUntypedBase {
+++ public:
+++ MatcherUntypedBase() = default;
+++
+++ MatcherUntypedBase(MatcherUntypedBase const&) = default;
+++ MatcherUntypedBase(MatcherUntypedBase&&) = default;
+++
+++ MatcherUntypedBase& operator = (MatcherUntypedBase const&) = delete;
+++ MatcherUntypedBase& operator = (MatcherUntypedBase&&) = delete;
+++
+++ std::string toString() const;
+++
+++ protected:
+++ virtual ~MatcherUntypedBase(); // = default;
+++ virtual std::string describe() const = 0;
+++ mutable std::string m_cachedToString;
+++ };
+++
+++
+++ template<typename T>
+++ class MatcherBase : public MatcherUntypedBase {
+++ public:
+++ virtual bool match( T const& arg ) const = 0;
+++ };
+++
+++ namespace Detail {
+++
+++ template<typename ArgT>
+++ class MatchAllOf final : public MatcherBase<ArgT> {
+++ std::vector<MatcherBase<ArgT> const*> m_matchers;
+++
+++ public:
+++ MatchAllOf() = default;
+++ MatchAllOf(MatchAllOf const&) = delete;
+++ MatchAllOf& operator=(MatchAllOf const&) = delete;
+++ MatchAllOf(MatchAllOf&&) = default;
+++ MatchAllOf& operator=(MatchAllOf&&) = default;
+++
+++
+++ bool match( ArgT const& arg ) const override {
+++ for( auto matcher : m_matchers ) {
+++ if (!matcher->match(arg))
+++ return false;
+++ }
+++ return true;
+++ }
+++ std::string describe() const override {
+++ std::string description;
+++ description.reserve( 4 + m_matchers.size()*32 );
+++ description += "( ";
+++ bool first = true;
+++ for( auto matcher : m_matchers ) {
+++ if( first )
+++ first = false;
+++ else
+++ description += " and ";
+++ description += matcher->toString();
+++ }
+++ description += " )";
+++ return description;
+++ }
+++
+++ friend MatchAllOf operator&& (MatchAllOf&& lhs, MatcherBase<ArgT> const& rhs) {
+++ lhs.m_matchers.push_back(&rhs);
+++ return CATCH_MOVE(lhs);
+++ }
+++ friend MatchAllOf operator&& (MatcherBase<ArgT> const& lhs, MatchAllOf&& rhs) {
+++ rhs.m_matchers.insert(rhs.m_matchers.begin(), &lhs);
+++ return CATCH_MOVE(rhs);
+++ }
+++ };
+++
+++ //! lvalue overload is intentionally deleted, users should
+++ //! not be trying to compose stored composition matchers
+++ template<typename ArgT>
+++ MatchAllOf<ArgT> operator&& (MatchAllOf<ArgT> const& lhs, MatcherBase<ArgT> const& rhs) = delete;
+++ //! lvalue overload is intentionally deleted, users should
+++ //! not be trying to compose stored composition matchers
+++ template<typename ArgT>
+++ MatchAllOf<ArgT> operator&& (MatcherBase<ArgT> const& lhs, MatchAllOf<ArgT> const& rhs) = delete;
+++
+++ template<typename ArgT>
+++ class MatchAnyOf final : public MatcherBase<ArgT> {
+++ std::vector<MatcherBase<ArgT> const*> m_matchers;
+++ public:
+++ MatchAnyOf() = default;
+++ MatchAnyOf(MatchAnyOf const&) = delete;
+++ MatchAnyOf& operator=(MatchAnyOf const&) = delete;
+++ MatchAnyOf(MatchAnyOf&&) = default;
+++ MatchAnyOf& operator=(MatchAnyOf&&) = default;
+++
+++ bool match( ArgT const& arg ) const override {
+++ for( auto matcher : m_matchers ) {
+++ if (matcher->match(arg))
+++ return true;
+++ }
+++ return false;
+++ }
+++ std::string describe() const override {
+++ std::string description;
+++ description.reserve( 4 + m_matchers.size()*32 );
+++ description += "( ";
+++ bool first = true;
+++ for( auto matcher : m_matchers ) {
+++ if( first )
+++ first = false;
+++ else
+++ description += " or ";
+++ description += matcher->toString();
+++ }
+++ description += " )";
+++ return description;
+++ }
+++
+++ friend MatchAnyOf operator|| (MatchAnyOf&& lhs, MatcherBase<ArgT> const& rhs) {
+++ lhs.m_matchers.push_back(&rhs);
+++ return CATCH_MOVE(lhs);
+++ }
+++ friend MatchAnyOf operator|| (MatcherBase<ArgT> const& lhs, MatchAnyOf&& rhs) {
+++ rhs.m_matchers.insert(rhs.m_matchers.begin(), &lhs);
+++ return CATCH_MOVE(rhs);
+++ }
+++ };
+++
+++ //! lvalue overload is intentionally deleted, users should
+++ //! not be trying to compose stored composition matchers
+++ template<typename ArgT>
+++ MatchAnyOf<ArgT> operator|| (MatchAnyOf<ArgT> const& lhs, MatcherBase<ArgT> const& rhs) = delete;
+++ //! lvalue overload is intentionally deleted, users should
+++ //! not be trying to compose stored composition matchers
+++ template<typename ArgT>
+++ MatchAnyOf<ArgT> operator|| (MatcherBase<ArgT> const& lhs, MatchAnyOf<ArgT> const& rhs) = delete;
+++
+++ template<typename ArgT>
+++ class MatchNotOf final : public MatcherBase<ArgT> {
+++ MatcherBase<ArgT> const& m_underlyingMatcher;
+++
+++ public:
+++ explicit MatchNotOf( MatcherBase<ArgT> const& underlyingMatcher ):
+++ m_underlyingMatcher( underlyingMatcher )
+++ {}
+++
+++ bool match( ArgT const& arg ) const override {
+++ return !m_underlyingMatcher.match( arg );
+++ }
+++
+++ std::string describe() const override {
+++ return "not " + m_underlyingMatcher.toString();
+++ }
+++ };
+++
+++ } // namespace Detail
+++
+++ template <typename T>
+++ Detail::MatchAllOf<T> operator&& (MatcherBase<T> const& lhs, MatcherBase<T> const& rhs) {
+++ return Detail::MatchAllOf<T>{} && lhs && rhs;
+++ }
+++ template <typename T>
+++ Detail::MatchAnyOf<T> operator|| (MatcherBase<T> const& lhs, MatcherBase<T> const& rhs) {
+++ return Detail::MatchAnyOf<T>{} || lhs || rhs;
+++ }
+++
+++ template <typename T>
+++ Detail::MatchNotOf<T> operator! (MatcherBase<T> const& matcher) {
+++ return Detail::MatchNotOf<T>{ matcher };
+++ }
+++
+++
+++} // namespace Matchers
+++} // namespace Catch
+++
+++
+++#if defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+++ #define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+++ #define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+++
+++ #define CATCH_CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CATCH_CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+++ #define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CATCH_CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+++
+++ #define CATCH_CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+++ #define CATCH_REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CATCH_REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+++
+++#elif defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+++
+++ #define CATCH_REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
+++ #define CATCH_REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+++
+++ #define CATCH_CHECK_THROWS_WITH( expr, matcher ) (void)(0)
+++ #define CATCH_CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+++
+++ #define CATCH_CHECK_THAT( arg, matcher ) (void)(0)
+++ #define CATCH_REQUIRE_THAT( arg, matcher ) (void)(0)
+++
+++#elif !defined(CATCH_CONFIG_PREFIX_ALL) && !defined(CATCH_CONFIG_DISABLE)
+++
+++ #define REQUIRE_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "REQUIRE_THROWS_WITH", Catch::ResultDisposition::Normal, matcher, expr )
+++ #define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "REQUIRE_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::Normal, matcher, expr )
+++
+++ #define CHECK_THROWS_WITH( expr, matcher ) INTERNAL_CATCH_THROWS_STR_MATCHES( "CHECK_THROWS_WITH", Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+++ #define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) INTERNAL_CATCH_THROWS_MATCHES( "CHECK_THROWS_MATCHES", exceptionType, Catch::ResultDisposition::ContinueOnFailure, matcher, expr )
+++
+++ #define CHECK_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "CHECK_THAT", matcher, Catch::ResultDisposition::ContinueOnFailure, arg )
+++ #define REQUIRE_THAT( arg, matcher ) INTERNAL_CHECK_THAT( "REQUIRE_THAT", matcher, Catch::ResultDisposition::Normal, arg )
+++
+++#elif !defined(CATCH_CONFIG_PREFIX_ALL) && defined(CATCH_CONFIG_DISABLE)
+++
+++ #define REQUIRE_THROWS_WITH( expr, matcher ) (void)(0)
+++ #define REQUIRE_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+++
+++ #define CHECK_THROWS_WITH( expr, matcher ) (void)(0)
+++ #define CHECK_THROWS_MATCHES( expr, exceptionType, matcher ) (void)(0)
+++
+++ #define CHECK_THAT( arg, matcher ) (void)(0)
+++ #define REQUIRE_THAT( arg, matcher ) (void)(0)
+++
+++#endif // end of user facing macro declarations
+++
+++#endif // CATCH_MATCHERS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
+++#define CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
+++#define CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
+++
+++
+++#include <array>
+++#include <algorithm>
+++#include <string>
+++#include <type_traits>
+++
+++namespace Catch {
+++namespace Matchers {
+++ class MatcherGenericBase : public MatcherUntypedBase {
+++ public:
+++ MatcherGenericBase() = default;
+++ ~MatcherGenericBase() override; // = default;
+++
+++ MatcherGenericBase(MatcherGenericBase const&) = default;
+++ MatcherGenericBase(MatcherGenericBase&&) = default;
+++
+++ MatcherGenericBase& operator=(MatcherGenericBase const&) = delete;
+++ MatcherGenericBase& operator=(MatcherGenericBase&&) = delete;
+++ };
+++
+++
+++ namespace Detail {
+++ template<std::size_t N, std::size_t M>
+++ std::array<void const*, N + M> array_cat(std::array<void const*, N> && lhs, std::array<void const*, M> && rhs) {
+++ std::array<void const*, N + M> arr{};
+++ std::copy_n(lhs.begin(), N, arr.begin());
+++ std::copy_n(rhs.begin(), M, arr.begin() + N);
+++ return arr;
+++ }
+++
+++ template<std::size_t N>
+++ std::array<void const*, N+1> array_cat(std::array<void const*, N> && lhs, void const* rhs) {
+++ std::array<void const*, N+1> arr{};
+++ std::copy_n(lhs.begin(), N, arr.begin());
+++ arr[N] = rhs;
+++ return arr;
+++ }
+++
+++ template<std::size_t N>
+++ std::array<void const*, N+1> array_cat(void const* lhs, std::array<void const*, N> && rhs) {
+++ std::array<void const*, N + 1> arr{ {lhs} };
+++ std::copy_n(rhs.begin(), N, arr.begin() + 1);
+++ return arr;
+++ }
+++
+++ template<typename T>
+++ using is_generic_matcher = std::is_base_of<
+++ Catch::Matchers::MatcherGenericBase,
+++ std::remove_cv_t<std::remove_reference_t<T>>
+++ >;
+++
+++ template<typename... Ts>
+++ using are_generic_matchers = Catch::Detail::conjunction<is_generic_matcher<Ts>...>;
+++
+++ template<typename T>
+++ using is_matcher = std::is_base_of<
+++ Catch::Matchers::MatcherUntypedBase,
+++ std::remove_cv_t<std::remove_reference_t<T>>
+++ >;
+++
+++
+++ template<std::size_t N, typename Arg>
+++ bool match_all_of(Arg&&, std::array<void const*, N> const&, std::index_sequence<>) {
+++ return true;
+++ }
+++
+++ template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
+++ bool match_all_of(Arg&& arg, std::array<void const*, N> const& matchers, std::index_sequence<Idx, Indices...>) {
+++ return static_cast<T const*>(matchers[Idx])->match(arg) && match_all_of<MatcherTs...>(arg, matchers, std::index_sequence<Indices...>{});
+++ }
+++
+++
+++ template<std::size_t N, typename Arg>
+++ bool match_any_of(Arg&&, std::array<void const*, N> const&, std::index_sequence<>) {
+++ return false;
+++ }
+++
+++ template<typename T, typename... MatcherTs, std::size_t N, typename Arg, std::size_t Idx, std::size_t... Indices>
+++ bool match_any_of(Arg&& arg, std::array<void const*, N> const& matchers, std::index_sequence<Idx, Indices...>) {
+++ return static_cast<T const*>(matchers[Idx])->match(arg) || match_any_of<MatcherTs...>(arg, matchers, std::index_sequence<Indices...>{});
+++ }
+++
+++ std::string describe_multi_matcher(StringRef combine, std::string const* descriptions_begin, std::string const* descriptions_end);
+++
+++ template<typename... MatcherTs, std::size_t... Idx>
+++ std::string describe_multi_matcher(StringRef combine, std::array<void const*, sizeof...(MatcherTs)> const& matchers, std::index_sequence<Idx...>) {
+++ std::array<std::string, sizeof...(MatcherTs)> descriptions {{
+++ static_cast<MatcherTs const*>(matchers[Idx])->toString()...
+++ }};
+++
+++ return describe_multi_matcher(combine, descriptions.data(), descriptions.data() + descriptions.size());
+++ }
+++
+++
+++ template<typename... MatcherTs>
+++ class MatchAllOfGeneric final : public MatcherGenericBase {
+++ public:
+++ MatchAllOfGeneric(MatchAllOfGeneric const&) = delete;
+++ MatchAllOfGeneric& operator=(MatchAllOfGeneric const&) = delete;
+++ MatchAllOfGeneric(MatchAllOfGeneric&&) = default;
+++ MatchAllOfGeneric& operator=(MatchAllOfGeneric&&) = default;
+++
+++ MatchAllOfGeneric(MatcherTs const&... matchers) : m_matchers{ {std::addressof(matchers)...} } {}
+++ explicit MatchAllOfGeneric(std::array<void const*, sizeof...(MatcherTs)> matchers) : m_matchers{matchers} {}
+++
+++ template<typename Arg>
+++ bool match(Arg&& arg) const {
+++ return match_all_of<MatcherTs...>(arg, m_matchers, std::index_sequence_for<MatcherTs...>{});
+++ }
+++
+++ std::string describe() const override {
+++ return describe_multi_matcher<MatcherTs...>(" and "_sr, m_matchers, std::index_sequence_for<MatcherTs...>{});
+++ }
+++
+++ // Has to be public to enable the concatenating operators
+++ // below, because they are not friend of the RHS, only LHS,
+++ // and thus cannot access private fields of RHS
+++ std::array<void const*, sizeof...( MatcherTs )> m_matchers;
+++
+++
+++ //! Avoids type nesting for `GenericAllOf && GenericAllOf` case
+++ template<typename... MatchersRHS>
+++ friend
+++ MatchAllOfGeneric<MatcherTs..., MatchersRHS...> operator && (
+++ MatchAllOfGeneric<MatcherTs...>&& lhs,
+++ MatchAllOfGeneric<MatchersRHS...>&& rhs) {
+++ return MatchAllOfGeneric<MatcherTs..., MatchersRHS...>{array_cat(CATCH_MOVE(lhs.m_matchers), CATCH_MOVE(rhs.m_matchers))};
+++ }
+++
+++ //! Avoids type nesting for `GenericAllOf && some matcher` case
+++ template<typename MatcherRHS>
+++ friend std::enable_if_t<is_matcher<MatcherRHS>::value,
+++ MatchAllOfGeneric<MatcherTs..., MatcherRHS>> operator && (
+++ MatchAllOfGeneric<MatcherTs...>&& lhs,
+++ MatcherRHS const& rhs) {
+++ return MatchAllOfGeneric<MatcherTs..., MatcherRHS>{array_cat(CATCH_MOVE(lhs.m_matchers), static_cast<void const*>(&rhs))};
+++ }
+++
+++ //! Avoids type nesting for `some matcher && GenericAllOf` case
+++ template<typename MatcherLHS>
+++ friend std::enable_if_t<is_matcher<MatcherLHS>::value,
+++ MatchAllOfGeneric<MatcherLHS, MatcherTs...>> operator && (
+++ MatcherLHS const& lhs,
+++ MatchAllOfGeneric<MatcherTs...>&& rhs) {
+++ return MatchAllOfGeneric<MatcherLHS, MatcherTs...>{array_cat(static_cast<void const*>(std::addressof(lhs)), CATCH_MOVE(rhs.m_matchers))};
+++ }
+++ };
+++
+++
+++ template<typename... MatcherTs>
+++ class MatchAnyOfGeneric final : public MatcherGenericBase {
+++ public:
+++ MatchAnyOfGeneric(MatchAnyOfGeneric const&) = delete;
+++ MatchAnyOfGeneric& operator=(MatchAnyOfGeneric const&) = delete;
+++ MatchAnyOfGeneric(MatchAnyOfGeneric&&) = default;
+++ MatchAnyOfGeneric& operator=(MatchAnyOfGeneric&&) = default;
+++
+++ MatchAnyOfGeneric(MatcherTs const&... matchers) : m_matchers{ {std::addressof(matchers)...} } {}
+++ explicit MatchAnyOfGeneric(std::array<void const*, sizeof...(MatcherTs)> matchers) : m_matchers{matchers} {}
+++
+++ template<typename Arg>
+++ bool match(Arg&& arg) const {
+++ return match_any_of<MatcherTs...>(arg, m_matchers, std::index_sequence_for<MatcherTs...>{});
+++ }
+++
+++ std::string describe() const override {
+++ return describe_multi_matcher<MatcherTs...>(" or "_sr, m_matchers, std::index_sequence_for<MatcherTs...>{});
+++ }
+++
+++
+++ // Has to be public to enable the concatenating operators
+++ // below, because they are not friend of the RHS, only LHS,
+++ // and thus cannot access private fields of RHS
+++ std::array<void const*, sizeof...( MatcherTs )> m_matchers;
+++
+++ //! Avoids type nesting for `GenericAnyOf || GenericAnyOf` case
+++ template<typename... MatchersRHS>
+++ friend MatchAnyOfGeneric<MatcherTs..., MatchersRHS...> operator || (
+++ MatchAnyOfGeneric<MatcherTs...>&& lhs,
+++ MatchAnyOfGeneric<MatchersRHS...>&& rhs) {
+++ return MatchAnyOfGeneric<MatcherTs..., MatchersRHS...>{array_cat(CATCH_MOVE(lhs.m_matchers), CATCH_MOVE(rhs.m_matchers))};
+++ }
+++
+++ //! Avoids type nesting for `GenericAnyOf || some matcher` case
+++ template<typename MatcherRHS>
+++ friend std::enable_if_t<is_matcher<MatcherRHS>::value,
+++ MatchAnyOfGeneric<MatcherTs..., MatcherRHS>> operator || (
+++ MatchAnyOfGeneric<MatcherTs...>&& lhs,
+++ MatcherRHS const& rhs) {
+++ return MatchAnyOfGeneric<MatcherTs..., MatcherRHS>{array_cat(CATCH_MOVE(lhs.m_matchers), static_cast<void const*>(std::addressof(rhs)))};
+++ }
+++
+++ //! Avoids type nesting for `some matcher || GenericAnyOf` case
+++ template<typename MatcherLHS>
+++ friend std::enable_if_t<is_matcher<MatcherLHS>::value,
+++ MatchAnyOfGeneric<MatcherLHS, MatcherTs...>> operator || (
+++ MatcherLHS const& lhs,
+++ MatchAnyOfGeneric<MatcherTs...>&& rhs) {
+++ return MatchAnyOfGeneric<MatcherLHS, MatcherTs...>{array_cat(static_cast<void const*>(std::addressof(lhs)), CATCH_MOVE(rhs.m_matchers))};
+++ }
+++ };
+++
+++
+++ template<typename MatcherT>
+++ class MatchNotOfGeneric final : public MatcherGenericBase {
+++ MatcherT const& m_matcher;
+++
+++ public:
+++ MatchNotOfGeneric(MatchNotOfGeneric const&) = delete;
+++ MatchNotOfGeneric& operator=(MatchNotOfGeneric const&) = delete;
+++ MatchNotOfGeneric(MatchNotOfGeneric&&) = default;
+++ MatchNotOfGeneric& operator=(MatchNotOfGeneric&&) = default;
+++
+++ explicit MatchNotOfGeneric(MatcherT const& matcher) : m_matcher{matcher} {}
+++
+++ template<typename Arg>
+++ bool match(Arg&& arg) const {
+++ return !m_matcher.match(arg);
+++ }
+++
+++ std::string describe() const override {
+++ return "not " + m_matcher.toString();
+++ }
+++
+++ //! Negating negation can just unwrap and return underlying matcher
+++ friend MatcherT const& operator ! (MatchNotOfGeneric<MatcherT> const& matcher) {
+++ return matcher.m_matcher;
+++ }
+++ };
+++ } // namespace Detail
+++
+++
+++ // compose only generic matchers
+++ template<typename MatcherLHS, typename MatcherRHS>
+++ std::enable_if_t<Detail::are_generic_matchers<MatcherLHS, MatcherRHS>::value, Detail::MatchAllOfGeneric<MatcherLHS, MatcherRHS>>
+++ operator && (MatcherLHS const& lhs, MatcherRHS const& rhs) {
+++ return { lhs, rhs };
+++ }
+++
+++ template<typename MatcherLHS, typename MatcherRHS>
+++ std::enable_if_t<Detail::are_generic_matchers<MatcherLHS, MatcherRHS>::value, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherRHS>>
+++ operator || (MatcherLHS const& lhs, MatcherRHS const& rhs) {
+++ return { lhs, rhs };
+++ }
+++
+++ //! Wrap provided generic matcher in generic negator
+++ template<typename MatcherT>
+++ std::enable_if_t<Detail::is_generic_matcher<MatcherT>::value, Detail::MatchNotOfGeneric<MatcherT>>
+++ operator ! (MatcherT const& matcher) {
+++ return Detail::MatchNotOfGeneric<MatcherT>{matcher};
+++ }
+++
+++
+++ // compose mixed generic and non-generic matchers
+++ template<typename MatcherLHS, typename ArgRHS>
+++ std::enable_if_t<Detail::is_generic_matcher<MatcherLHS>::value, Detail::MatchAllOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
+++ operator && (MatcherLHS const& lhs, MatcherBase<ArgRHS> const& rhs) {
+++ return { lhs, rhs };
+++ }
+++
+++ template<typename ArgLHS, typename MatcherRHS>
+++ std::enable_if_t<Detail::is_generic_matcher<MatcherRHS>::value, Detail::MatchAllOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
+++ operator && (MatcherBase<ArgLHS> const& lhs, MatcherRHS const& rhs) {
+++ return { lhs, rhs };
+++ }
+++
+++ template<typename MatcherLHS, typename ArgRHS>
+++ std::enable_if_t<Detail::is_generic_matcher<MatcherLHS>::value, Detail::MatchAnyOfGeneric<MatcherLHS, MatcherBase<ArgRHS>>>
+++ operator || (MatcherLHS const& lhs, MatcherBase<ArgRHS> const& rhs) {
+++ return { lhs, rhs };
+++ }
+++
+++ template<typename ArgLHS, typename MatcherRHS>
+++ std::enable_if_t<Detail::is_generic_matcher<MatcherRHS>::value, Detail::MatchAnyOfGeneric<MatcherBase<ArgLHS>, MatcherRHS>>
+++ operator || (MatcherBase<ArgLHS> const& lhs, MatcherRHS const& rhs) {
+++ return { lhs, rhs };
+++ }
+++
+++} // namespace Matchers
+++} // namespace Catch
+++
+++#endif // CATCH_MATCHERS_TEMPLATED_HPP_INCLUDED
+++
+++namespace Catch {
+++ namespace Matchers {
+++
+++ class IsEmptyMatcher final : public MatcherGenericBase {
+++ public:
+++ template <typename RangeLike>
+++ bool match(RangeLike&& rng) const {
+++#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
+++ using Catch::Detail::empty;
+++#else
+++ using std::empty;
+++#endif
+++ return empty(rng);
+++ }
+++
+++ std::string describe() const override;
+++ };
+++
+++ class HasSizeMatcher final : public MatcherGenericBase {
+++ std::size_t m_target_size;
+++ public:
+++ explicit HasSizeMatcher(std::size_t target_size):
+++ m_target_size(target_size)
+++ {}
+++
+++ template <typename RangeLike>
+++ bool match(RangeLike&& rng) const {
+++#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
+++ using Catch::Detail::size;
+++#else
+++ using std::size;
+++#endif
+++ return size(rng) == m_target_size;
+++ }
+++
+++ std::string describe() const override;
+++ };
+++
+++ template <typename Matcher>
+++ class SizeMatchesMatcher final : public MatcherGenericBase {
+++ Matcher m_matcher;
+++ public:
+++ explicit SizeMatchesMatcher(Matcher m):
+++ m_matcher(CATCH_MOVE(m))
+++ {}
+++
+++ template <typename RangeLike>
+++ bool match(RangeLike&& rng) const {
+++#if defined(CATCH_CONFIG_POLYFILL_NONMEMBER_CONTAINER_ACCESS)
+++ using Catch::Detail::size;
+++#else
+++ using std::size;
+++#endif
+++ return m_matcher.match(size(rng));
+++ }
+++
+++ std::string describe() const override {
+++ return "size matches " + m_matcher.describe();
+++ }
+++ };
+++
+++
+++ //! Creates a matcher that accepts empty ranges/containers
+++ IsEmptyMatcher IsEmpty();
+++ //! Creates a matcher that accepts ranges/containers with specific size
+++ HasSizeMatcher SizeIs(std::size_t sz);
+++ template <typename Matcher>
+++ std::enable_if_t<Detail::is_matcher<Matcher>::value,
+++ SizeMatchesMatcher<Matcher>> SizeIs(Matcher&& m) {
+++ return SizeMatchesMatcher<Matcher>{CATCH_FORWARD(m)};
+++ }
+++
+++ } // end namespace Matchers
+++} // end namespace Catch
+++
+++#endif // CATCH_MATCHERS_CONTAINER_PROPERTIES_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
+++#define CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
+++
+++
+++#include <algorithm>
+++#include <functional>
+++
+++namespace Catch {
+++ namespace Matchers {
+++ //! Matcher for checking that an element in range is equal to specific element
+++ template <typename T, typename Equality>
+++ class ContainsElementMatcher final : public MatcherGenericBase {
+++ T m_desired;
+++ Equality m_eq;
+++ public:
+++ template <typename T2, typename Equality2>
+++ ContainsElementMatcher(T2&& target, Equality2&& predicate):
+++ m_desired(CATCH_FORWARD(target)),
+++ m_eq(CATCH_FORWARD(predicate))
+++ {}
+++
+++ std::string describe() const override {
+++ return "contains element " + Catch::Detail::stringify(m_desired);
+++ }
+++
+++ template <typename RangeLike>
+++ bool match( RangeLike&& rng ) const {
+++ for ( auto&& elem : rng ) {
+++ if ( m_eq( elem, m_desired ) ) { return true; }
+++ }
+++ return false;
+++ }
+++ };
+++
+++ //! Meta-matcher for checking that an element in a range matches a specific matcher
+++ template <typename Matcher>
+++ class ContainsMatcherMatcher final : public MatcherGenericBase {
+++ Matcher m_matcher;
+++ public:
+++ // Note that we do a copy+move to avoid having to SFINAE this
+++ // constructor (and also avoid some perfect forwarding failure
+++ // cases)
+++ ContainsMatcherMatcher(Matcher matcher):
+++ m_matcher(CATCH_MOVE(matcher))
+++ {}
+++
+++ template <typename RangeLike>
+++ bool match(RangeLike&& rng) const {
+++ for (auto&& elem : rng) {
+++ if (m_matcher.match(elem)) {
+++ return true;
+++ }
+++ }
+++ return false;
+++ }
+++
+++ std::string describe() const override {
+++ return "contains element matching " + m_matcher.describe();
+++ }
+++ };
+++
+++ /**
+++ * Creates a matcher that checks whether a range contains a specific element.
+++ *
+++ * Uses `std::equal_to` to do the comparison
+++ */
+++ template <typename T>
+++ std::enable_if_t<!Detail::is_matcher<T>::value,
+++ ContainsElementMatcher<T, std::equal_to<>>> Contains(T&& elem) {
+++ return { CATCH_FORWARD(elem), std::equal_to<>{} };
+++ }
+++
+++ //! Creates a matcher that checks whether a range contains element matching a matcher
+++ template <typename Matcher>
+++ std::enable_if_t<Detail::is_matcher<Matcher>::value,
+++ ContainsMatcherMatcher<Matcher>> Contains(Matcher&& matcher) {
+++ return { CATCH_FORWARD(matcher) };
+++ }
+++
+++ /**
+++ * Creates a matcher that checks whether a range contains a specific element.
+++ *
+++ * Uses `eq` to do the comparisons, the element is provided on the rhs
+++ */
+++ template <typename T, typename Equality>
+++ ContainsElementMatcher<T, Equality> Contains(T&& elem, Equality&& eq) {
+++ return { CATCH_FORWARD(elem), CATCH_FORWARD(eq) };
+++ }
+++
+++ }
+++}
+++
+++#endif // CATCH_MATCHERS_CONTAINS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
+++#define CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++namespace Matchers {
+++
+++class ExceptionMessageMatcher final : public MatcherBase<std::exception> {
+++ std::string m_message;
+++public:
+++
+++ ExceptionMessageMatcher(std::string const& message):
+++ m_message(message)
+++ {}
+++
+++ bool match(std::exception const& ex) const override;
+++
+++ std::string describe() const override;
+++};
+++
+++//! Creates a matcher that checks whether a std derived exception has the provided message
+++ExceptionMessageMatcher Message(std::string const& message);
+++
+++template <typename StringMatcherType>
+++class ExceptionMessageMatchesMatcher final
+++ : public MatcherBase<std::exception> {
+++ StringMatcherType m_matcher;
+++
+++public:
+++ ExceptionMessageMatchesMatcher( StringMatcherType matcher ):
+++ m_matcher( CATCH_MOVE( matcher ) ) {}
+++
+++ bool match( std::exception const& ex ) const override {
+++ return m_matcher.match( ex.what() );
+++ }
+++
+++ std::string describe() const override {
+++ return " matches \"" + m_matcher.describe() + '"';
+++ }
+++};
+++
+++//! Creates a matcher that checks whether a message from an std derived
+++//! exception matches a provided matcher
+++template <typename StringMatcherType>
+++ExceptionMessageMatchesMatcher<StringMatcherType>
+++MessageMatches( StringMatcherType&& matcher ) {
+++ return { CATCH_FORWARD( matcher ) };
+++}
+++
+++} // namespace Matchers
+++} // namespace Catch
+++
+++#endif // CATCH_MATCHERS_EXCEPTION_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
+++#define CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++namespace Matchers {
+++
+++ namespace Detail {
+++ enum class FloatingPointKind : uint8_t;
+++ }
+++
+++ class WithinAbsMatcher final : public MatcherBase<double> {
+++ public:
+++ WithinAbsMatcher(double target, double margin);
+++ bool match(double const& matchee) const override;
+++ std::string describe() const override;
+++ private:
+++ double m_target;
+++ double m_margin;
+++ };
+++
+++ //! Creates a matcher that accepts numbers within certain range of target
+++ WithinAbsMatcher WithinAbs( double target, double margin );
+++
+++
+++
+++ class WithinUlpsMatcher final : public MatcherBase<double> {
+++ public:
+++ WithinUlpsMatcher( double target,
+++ uint64_t ulps,
+++ Detail::FloatingPointKind baseType );
+++ bool match(double const& matchee) const override;
+++ std::string describe() const override;
+++ private:
+++ double m_target;
+++ uint64_t m_ulps;
+++ Detail::FloatingPointKind m_type;
+++ };
+++
+++ //! Creates a matcher that accepts doubles within certain ULP range of target
+++ WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff);
+++ //! Creates a matcher that accepts floats within certain ULP range of target
+++ WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff);
+++
+++
+++
+++ // Given IEEE-754 format for floats and doubles, we can assume
+++ // that float -> double promotion is lossless. Given this, we can
+++ // assume that if we do the standard relative comparison of
+++ // |lhs - rhs| <= epsilon * max(fabs(lhs), fabs(rhs)), then we get
+++ // the same result if we do this for floats, as if we do this for
+++ // doubles that were promoted from floats.
+++ class WithinRelMatcher final : public MatcherBase<double> {
+++ public:
+++ WithinRelMatcher( double target, double epsilon );
+++ bool match(double const& matchee) const override;
+++ std::string describe() const override;
+++ private:
+++ double m_target;
+++ double m_epsilon;
+++ };
+++
+++ //! Creates a matcher that accepts doubles within certain relative range of target
+++ WithinRelMatcher WithinRel(double target, double eps);
+++ //! Creates a matcher that accepts doubles within 100*DBL_EPS relative range of target
+++ WithinRelMatcher WithinRel(double target);
+++ //! Creates a matcher that accepts doubles within certain relative range of target
+++ WithinRelMatcher WithinRel(float target, float eps);
+++ //! Creates a matcher that accepts floats within 100*FLT_EPS relative range of target
+++ WithinRelMatcher WithinRel(float target);
+++
+++
+++
+++ class IsNaNMatcher final : public MatcherBase<double> {
+++ public:
+++ IsNaNMatcher() = default;
+++ bool match( double const& matchee ) const override;
+++ std::string describe() const override;
+++ };
+++
+++ IsNaNMatcher IsNaN();
+++
+++} // namespace Matchers
+++} // namespace Catch
+++
+++#endif // CATCH_MATCHERS_FLOATING_POINT_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
+++#define CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
+++
+++
+++#include <string>
+++
+++namespace Catch {
+++namespace Matchers {
+++
+++namespace Detail {
+++ std::string finalizeDescription(const std::string& desc);
+++} // namespace Detail
+++
+++template <typename T, typename Predicate>
+++class PredicateMatcher final : public MatcherBase<T> {
+++ Predicate m_predicate;
+++ std::string m_description;
+++public:
+++
+++ PredicateMatcher(Predicate&& elem, std::string const& descr)
+++ :m_predicate(CATCH_FORWARD(elem)),
+++ m_description(Detail::finalizeDescription(descr))
+++ {}
+++
+++ bool match( T const& item ) const override {
+++ return m_predicate(item);
+++ }
+++
+++ std::string describe() const override {
+++ return m_description;
+++ }
+++};
+++
+++ /**
+++ * Creates a matcher that calls delegates `match` to the provided predicate.
+++ *
+++ * The user has to explicitly specify the argument type to the matcher
+++ */
+++ template<typename T, typename Pred>
+++ PredicateMatcher<T, Pred> Predicate(Pred&& predicate, std::string const& description = "") {
+++ static_assert(is_callable<Pred(T)>::value, "Predicate not callable with argument T");
+++ static_assert(std::is_same<bool, FunctionReturnType<Pred, T>>::value, "Predicate does not return bool");
+++ return PredicateMatcher<T, Pred>(CATCH_FORWARD(predicate), description);
+++ }
+++
+++} // namespace Matchers
+++} // namespace Catch
+++
+++#endif // CATCH_MATCHERS_PREDICATE_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
+++#define CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++ namespace Matchers {
+++ // Matcher for checking that all elements in range matches a given matcher.
+++ template <typename Matcher>
+++ class AllMatchMatcher final : public MatcherGenericBase {
+++ Matcher m_matcher;
+++ public:
+++ AllMatchMatcher(Matcher matcher):
+++ m_matcher(CATCH_MOVE(matcher))
+++ {}
+++
+++ std::string describe() const override {
+++ return "all match " + m_matcher.describe();
+++ }
+++
+++ template <typename RangeLike>
+++ bool match(RangeLike&& rng) const {
+++ for (auto&& elem : rng) {
+++ if (!m_matcher.match(elem)) {
+++ return false;
+++ }
+++ }
+++ return true;
+++ }
+++ };
+++
+++ // Matcher for checking that no element in range matches a given matcher.
+++ template <typename Matcher>
+++ class NoneMatchMatcher final : public MatcherGenericBase {
+++ Matcher m_matcher;
+++ public:
+++ NoneMatchMatcher(Matcher matcher):
+++ m_matcher(CATCH_MOVE(matcher))
+++ {}
+++
+++ std::string describe() const override {
+++ return "none match " + m_matcher.describe();
+++ }
+++
+++ template <typename RangeLike>
+++ bool match(RangeLike&& rng) const {
+++ for (auto&& elem : rng) {
+++ if (m_matcher.match(elem)) {
+++ return false;
+++ }
+++ }
+++ return true;
+++ }
+++ };
+++
+++ // Matcher for checking that at least one element in range matches a given matcher.
+++ template <typename Matcher>
+++ class AnyMatchMatcher final : public MatcherGenericBase {
+++ Matcher m_matcher;
+++ public:
+++ AnyMatchMatcher(Matcher matcher):
+++ m_matcher(CATCH_MOVE(matcher))
+++ {}
+++
+++ std::string describe() const override {
+++ return "any match " + m_matcher.describe();
+++ }
+++
+++ template <typename RangeLike>
+++ bool match(RangeLike&& rng) const {
+++ for (auto&& elem : rng) {
+++ if (m_matcher.match(elem)) {
+++ return true;
+++ }
+++ }
+++ return false;
+++ }
+++ };
+++
+++ // Matcher for checking that all elements in range are true.
+++ class AllTrueMatcher final : public MatcherGenericBase {
+++ public:
+++ std::string describe() const override;
+++
+++ template <typename RangeLike>
+++ bool match(RangeLike&& rng) const {
+++ for (auto&& elem : rng) {
+++ if (!elem) {
+++ return false;
+++ }
+++ }
+++ return true;
+++ }
+++ };
+++
+++ // Matcher for checking that no element in range is true.
+++ class NoneTrueMatcher final : public MatcherGenericBase {
+++ public:
+++ std::string describe() const override;
+++
+++ template <typename RangeLike>
+++ bool match(RangeLike&& rng) const {
+++ for (auto&& elem : rng) {
+++ if (elem) {
+++ return false;
+++ }
+++ }
+++ return true;
+++ }
+++ };
+++
+++ // Matcher for checking that any element in range is true.
+++ class AnyTrueMatcher final : public MatcherGenericBase {
+++ public:
+++ std::string describe() const override;
+++
+++ template <typename RangeLike>
+++ bool match(RangeLike&& rng) const {
+++ for (auto&& elem : rng) {
+++ if (elem) {
+++ return true;
+++ }
+++ }
+++ return false;
+++ }
+++ };
+++
+++ // Creates a matcher that checks whether all elements in a range match a matcher
+++ template <typename Matcher>
+++ AllMatchMatcher<Matcher> AllMatch(Matcher&& matcher) {
+++ return { CATCH_FORWARD(matcher) };
+++ }
+++
+++ // Creates a matcher that checks whether no element in a range matches a matcher.
+++ template <typename Matcher>
+++ NoneMatchMatcher<Matcher> NoneMatch(Matcher&& matcher) {
+++ return { CATCH_FORWARD(matcher) };
+++ }
+++
+++ // Creates a matcher that checks whether any element in a range matches a matcher.
+++ template <typename Matcher>
+++ AnyMatchMatcher<Matcher> AnyMatch(Matcher&& matcher) {
+++ return { CATCH_FORWARD(matcher) };
+++ }
+++
+++ // Creates a matcher that checks whether all elements in a range are true
+++ AllTrueMatcher AllTrue();
+++
+++ // Creates a matcher that checks whether no element in a range is true
+++ NoneTrueMatcher NoneTrue();
+++
+++ // Creates a matcher that checks whether any element in a range is true
+++ AnyTrueMatcher AnyTrue();
+++ }
+++}
+++
+++#endif // CATCH_MATCHERS_QUANTIFIERS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
+++#define CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
+++
+++
+++#include <algorithm>
+++#include <utility>
+++
+++namespace Catch {
+++ namespace Matchers {
+++
+++ /**
+++ * Matcher for checking that an element contains the same
+++ * elements in the same order
+++ */
+++ template <typename TargetRangeLike, typename Equality>
+++ class RangeEqualsMatcher final : public MatcherGenericBase {
+++ TargetRangeLike m_desired;
+++ Equality m_predicate;
+++
+++ public:
+++ template <typename TargetRangeLike2, typename Equality2>
+++ RangeEqualsMatcher( TargetRangeLike2&& range,
+++ Equality2&& predicate ):
+++ m_desired( CATCH_FORWARD( range ) ),
+++ m_predicate( CATCH_FORWARD( predicate ) ) {}
+++
+++ template <typename RangeLike>
+++ bool match( RangeLike&& rng ) const {
+++ auto rng_start = begin( rng );
+++ const auto rng_end = end( rng );
+++ auto target_start = begin( m_desired );
+++ const auto target_end = end( m_desired );
+++
+++ while (rng_start != rng_end && target_start != target_end) {
+++ if (!m_predicate(*rng_start, *target_start)) {
+++ return false;
+++ }
+++ ++rng_start;
+++ ++target_start;
+++ }
+++ return rng_start == rng_end && target_start == target_end;
+++ }
+++
+++ std::string describe() const override {
+++ return "elements are " + Catch::Detail::stringify( m_desired );
+++ }
+++ };
+++
+++ /**
+++ * Matcher for checking that an element contains the same
+++ * elements (but not necessarily in the same order)
+++ */
+++ template <typename TargetRangeLike, typename Equality>
+++ class UnorderedRangeEqualsMatcher final : public MatcherGenericBase {
+++ TargetRangeLike m_desired;
+++ Equality m_predicate;
+++
+++ public:
+++ template <typename TargetRangeLike2, typename Equality2>
+++ UnorderedRangeEqualsMatcher( TargetRangeLike2&& range,
+++ Equality2&& predicate ):
+++ m_desired( CATCH_FORWARD( range ) ),
+++ m_predicate( CATCH_FORWARD( predicate ) ) {}
+++
+++ template <typename RangeLike>
+++ bool match( RangeLike&& rng ) const {
+++ using std::begin;
+++ using std::end;
+++ return Catch::Detail::is_permutation( begin( m_desired ),
+++ end( m_desired ),
+++ begin( rng ),
+++ end( rng ),
+++ m_predicate );
+++ }
+++
+++ std::string describe() const override {
+++ return "unordered elements are " +
+++ ::Catch::Detail::stringify( m_desired );
+++ }
+++ };
+++
+++ /**
+++ * Creates a matcher that checks if all elements in a range are equal
+++ * to all elements in another range.
+++ *
+++ * Uses `std::equal_to` to do the comparison
+++ */
+++ template <typename RangeLike>
+++ std::enable_if_t<!Detail::is_matcher<RangeLike>::value,
+++ RangeEqualsMatcher<RangeLike, std::equal_to<>>>
+++ RangeEquals( RangeLike&& range ) {
+++ return { CATCH_FORWARD( range ), std::equal_to<>{} };
+++ }
+++
+++ /**
+++ * Creates a matcher that checks if all elements in a range are equal
+++ * to all elements in another range.
+++ *
+++ * Uses to provided predicate `predicate` to do the comparisons
+++ */
+++ template <typename RangeLike, typename Equality>
+++ RangeEqualsMatcher<RangeLike, Equality>
+++ RangeEquals( RangeLike&& range, Equality&& predicate ) {
+++ return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
+++ }
+++
+++ /**
+++ * Creates a matcher that checks if all elements in a range are equal
+++ * to all elements in another range, in some permutation
+++ *
+++ * Uses `std::equal_to` to do the comparison
+++ */
+++ template <typename RangeLike>
+++ std::enable_if_t<
+++ !Detail::is_matcher<RangeLike>::value,
+++ UnorderedRangeEqualsMatcher<RangeLike, std::equal_to<>>>
+++ UnorderedRangeEquals( RangeLike&& range ) {
+++ return { CATCH_FORWARD( range ), std::equal_to<>{} };
+++ }
+++
+++ /**
+++ * Creates a matcher that checks if all elements in a range are equal
+++ * to all elements in another range, in some permutation.
+++ *
+++ * Uses to provided predicate `predicate` to do the comparisons
+++ */
+++ template <typename RangeLike, typename Equality>
+++ UnorderedRangeEqualsMatcher<RangeLike, Equality>
+++ UnorderedRangeEquals( RangeLike&& range, Equality&& predicate ) {
+++ return { CATCH_FORWARD( range ), CATCH_FORWARD( predicate ) };
+++ }
+++ } // namespace Matchers
+++} // namespace Catch
+++
+++#endif // CATCH_MATCHERS_RANGE_EQUALS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_MATCHERS_STRING_HPP_INCLUDED
+++#define CATCH_MATCHERS_STRING_HPP_INCLUDED
+++
+++
+++#include <string>
+++
+++namespace Catch {
+++namespace Matchers {
+++
+++ struct CasedString {
+++ CasedString( std::string const& str, CaseSensitive caseSensitivity );
+++ std::string adjustString( std::string const& str ) const;
+++ StringRef caseSensitivitySuffix() const;
+++
+++ CaseSensitive m_caseSensitivity;
+++ std::string m_str;
+++ };
+++
+++ class StringMatcherBase : public MatcherBase<std::string> {
+++ protected:
+++ CasedString m_comparator;
+++ StringRef m_operation;
+++
+++ public:
+++ StringMatcherBase( StringRef operation,
+++ CasedString const& comparator );
+++ std::string describe() const override;
+++ };
+++
+++ class StringEqualsMatcher final : public StringMatcherBase {
+++ public:
+++ StringEqualsMatcher( CasedString const& comparator );
+++ bool match( std::string const& source ) const override;
+++ };
+++ class StringContainsMatcher final : public StringMatcherBase {
+++ public:
+++ StringContainsMatcher( CasedString const& comparator );
+++ bool match( std::string const& source ) const override;
+++ };
+++ class StartsWithMatcher final : public StringMatcherBase {
+++ public:
+++ StartsWithMatcher( CasedString const& comparator );
+++ bool match( std::string const& source ) const override;
+++ };
+++ class EndsWithMatcher final : public StringMatcherBase {
+++ public:
+++ EndsWithMatcher( CasedString const& comparator );
+++ bool match( std::string const& source ) const override;
+++ };
+++
+++ class RegexMatcher final : public MatcherBase<std::string> {
+++ std::string m_regex;
+++ CaseSensitive m_caseSensitivity;
+++
+++ public:
+++ RegexMatcher( std::string regex, CaseSensitive caseSensitivity );
+++ bool match( std::string const& matchee ) const override;
+++ std::string describe() const override;
+++ };
+++
+++ //! Creates matcher that accepts strings that are exactly equal to `str`
+++ StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+++ //! Creates matcher that accepts strings that contain `str`
+++ StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+++ //! Creates matcher that accepts strings that _end_ with `str`
+++ EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+++ //! Creates matcher that accepts strings that _start_ with `str`
+++ StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+++ //! Creates matcher that accepts strings matching `regex`
+++ RegexMatcher Matches( std::string const& regex, CaseSensitive caseSensitivity = CaseSensitive::Yes );
+++
+++} // namespace Matchers
+++} // namespace Catch
+++
+++#endif // CATCH_MATCHERS_STRING_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_MATCHERS_VECTOR_HPP_INCLUDED
+++#define CATCH_MATCHERS_VECTOR_HPP_INCLUDED
+++
+++
+++#include <algorithm>
+++
+++namespace Catch {
+++namespace Matchers {
+++
+++ template<typename T, typename Alloc>
+++ class VectorContainsElementMatcher final : public MatcherBase<std::vector<T, Alloc>> {
+++ T const& m_comparator;
+++
+++ public:
+++ VectorContainsElementMatcher(T const& comparator):
+++ m_comparator(comparator)
+++ {}
+++
+++ bool match(std::vector<T, Alloc> const& v) const override {
+++ for (auto const& el : v) {
+++ if (el == m_comparator) {
+++ return true;
+++ }
+++ }
+++ return false;
+++ }
+++
+++ std::string describe() const override {
+++ return "Contains: " + ::Catch::Detail::stringify( m_comparator );
+++ }
+++ };
+++
+++ template<typename T, typename AllocComp, typename AllocMatch>
+++ class ContainsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
+++ std::vector<T, AllocComp> const& m_comparator;
+++
+++ public:
+++ ContainsMatcher(std::vector<T, AllocComp> const& comparator):
+++ m_comparator( comparator )
+++ {}
+++
+++ bool match(std::vector<T, AllocMatch> const& v) const override {
+++ // !TBD: see note in EqualsMatcher
+++ if (m_comparator.size() > v.size())
+++ return false;
+++ for (auto const& comparator : m_comparator) {
+++ auto present = false;
+++ for (const auto& el : v) {
+++ if (el == comparator) {
+++ present = true;
+++ break;
+++ }
+++ }
+++ if (!present) {
+++ return false;
+++ }
+++ }
+++ return true;
+++ }
+++ std::string describe() const override {
+++ return "Contains: " + ::Catch::Detail::stringify( m_comparator );
+++ }
+++ };
+++
+++ template<typename T, typename AllocComp, typename AllocMatch>
+++ class EqualsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
+++ std::vector<T, AllocComp> const& m_comparator;
+++
+++ public:
+++ EqualsMatcher(std::vector<T, AllocComp> const& comparator):
+++ m_comparator( comparator )
+++ {}
+++
+++ bool match(std::vector<T, AllocMatch> const& v) const override {
+++ // !TBD: This currently works if all elements can be compared using !=
+++ // - a more general approach would be via a compare template that defaults
+++ // to using !=. but could be specialised for, e.g. std::vector<T> etc
+++ // - then just call that directly
+++ if ( m_comparator.size() != v.size() ) { return false; }
+++ for ( std::size_t i = 0; i < v.size(); ++i ) {
+++ if ( !( m_comparator[i] == v[i] ) ) { return false; }
+++ }
+++ return true;
+++ }
+++ std::string describe() const override {
+++ return "Equals: " + ::Catch::Detail::stringify( m_comparator );
+++ }
+++ };
+++
+++ template<typename T, typename AllocComp, typename AllocMatch>
+++ class ApproxMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
+++ std::vector<T, AllocComp> const& m_comparator;
+++ mutable Catch::Approx approx = Catch::Approx::custom();
+++
+++ public:
+++ ApproxMatcher(std::vector<T, AllocComp> const& comparator):
+++ m_comparator( comparator )
+++ {}
+++
+++ bool match(std::vector<T, AllocMatch> const& v) const override {
+++ if (m_comparator.size() != v.size())
+++ return false;
+++ for (std::size_t i = 0; i < v.size(); ++i)
+++ if (m_comparator[i] != approx(v[i]))
+++ return false;
+++ return true;
+++ }
+++ std::string describe() const override {
+++ return "is approx: " + ::Catch::Detail::stringify( m_comparator );
+++ }
+++ template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+++ ApproxMatcher& epsilon( T const& newEpsilon ) {
+++ approx.epsilon(static_cast<double>(newEpsilon));
+++ return *this;
+++ }
+++ template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+++ ApproxMatcher& margin( T const& newMargin ) {
+++ approx.margin(static_cast<double>(newMargin));
+++ return *this;
+++ }
+++ template <typename = std::enable_if_t<std::is_constructible<double, T>::value>>
+++ ApproxMatcher& scale( T const& newScale ) {
+++ approx.scale(static_cast<double>(newScale));
+++ return *this;
+++ }
+++ };
+++
+++ template<typename T, typename AllocComp, typename AllocMatch>
+++ class UnorderedEqualsMatcher final : public MatcherBase<std::vector<T, AllocMatch>> {
+++ std::vector<T, AllocComp> const& m_target;
+++
+++ public:
+++ UnorderedEqualsMatcher(std::vector<T, AllocComp> const& target):
+++ m_target(target)
+++ {}
+++ bool match(std::vector<T, AllocMatch> const& vec) const override {
+++ if (m_target.size() != vec.size()) {
+++ return false;
+++ }
+++ return std::is_permutation(m_target.begin(), m_target.end(), vec.begin());
+++ }
+++
+++ std::string describe() const override {
+++ return "UnorderedEquals: " + ::Catch::Detail::stringify(m_target);
+++ }
+++ };
+++
+++
+++ // The following functions create the actual matcher objects.
+++ // This allows the types to be inferred
+++
+++ //! Creates a matcher that matches vectors that contain all elements in `comparator`
+++ template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+++ ContainsMatcher<T, AllocComp, AllocMatch> Contains( std::vector<T, AllocComp> const& comparator ) {
+++ return ContainsMatcher<T, AllocComp, AllocMatch>(comparator);
+++ }
+++
+++ //! Creates a matcher that matches vectors that contain `comparator` as an element
+++ template<typename T, typename Alloc = std::allocator<T>>
+++ VectorContainsElementMatcher<T, Alloc> VectorContains( T const& comparator ) {
+++ return VectorContainsElementMatcher<T, Alloc>(comparator);
+++ }
+++
+++ //! Creates a matcher that matches vectors that are exactly equal to `comparator`
+++ template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+++ EqualsMatcher<T, AllocComp, AllocMatch> Equals( std::vector<T, AllocComp> const& comparator ) {
+++ return EqualsMatcher<T, AllocComp, AllocMatch>(comparator);
+++ }
+++
+++ //! Creates a matcher that matches vectors that `comparator` as an element
+++ template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+++ ApproxMatcher<T, AllocComp, AllocMatch> Approx( std::vector<T, AllocComp> const& comparator ) {
+++ return ApproxMatcher<T, AllocComp, AllocMatch>(comparator);
+++ }
+++
+++ //! Creates a matcher that matches vectors that is equal to `target` modulo permutation
+++ template<typename T, typename AllocComp = std::allocator<T>, typename AllocMatch = AllocComp>
+++ UnorderedEqualsMatcher<T, AllocComp, AllocMatch> UnorderedEquals(std::vector<T, AllocComp> const& target) {
+++ return UnorderedEqualsMatcher<T, AllocComp, AllocMatch>(target);
+++ }
+++
+++} // namespace Matchers
+++} // namespace Catch
+++
+++#endif // CATCH_MATCHERS_VECTOR_HPP_INCLUDED
+++
+++#endif // CATCH_MATCHERS_ALL_HPP_INCLUDED
+++
+++
+++/** \file
+++ * This is a convenience header for Catch2's Reporter support. It includes
+++ * **all** of Catch2 headers related to reporters, including all reporters.
+++ *
+++ * Generally the Catch2 users should use specific includes they need,
+++ * but this header can be used instead for ease-of-experimentation, or
+++ * just plain convenience, at the cost of (significantly) increased
+++ * compilation times.
+++ *
+++ * When a new header (reporter) is added to either the `reporter` folder,
+++ * or to the corresponding internal subfolder, it should be added here.
+++ */
+++
+++#ifndef CATCH_REPORTERS_ALL_HPP_INCLUDED
+++#define CATCH_REPORTERS_ALL_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+++#define CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
+++#define CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
+++#define CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
+++
+++
+++#include <map>
+++#include <string>
+++
+++namespace Catch {
+++ class ColourImpl;
+++
+++ /**
+++ * This is the base class for all reporters.
+++ *
+++ * If are writing a reporter, you must derive from this type, or one
+++ * of the helper reporter bases that are derived from this type.
+++ *
+++ * ReporterBase centralizes handling of various common tasks in reporters,
+++ * like storing the right stream for the reporters to write to, and
+++ * providing the default implementation of the different listing events.
+++ */
+++ class ReporterBase : public IEventListener {
+++ protected:
+++ //! The stream wrapper as passed to us by outside code
+++ Detail::unique_ptr<IStream> m_wrapped_stream;
+++ //! Cached output stream from `m_wrapped_stream` to reduce
+++ //! number of indirect calls needed to write output.
+++ std::ostream& m_stream;
+++ //! Colour implementation this reporter was configured for
+++ Detail::unique_ptr<ColourImpl> m_colour;
+++ //! The custom reporter options user passed down to the reporter
+++ std::map<std::string, std::string> m_customOptions;
+++
+++ public:
+++ ReporterBase( ReporterConfig&& config );
+++ ~ReporterBase() override; // = default;
+++
+++ /**
+++ * Provides a simple default listing of reporters.
+++ *
+++ * Should look roughly like the reporter listing in v2 and earlier
+++ * versions of Catch2.
+++ */
+++ void listReporters(
+++ std::vector<ReporterDescription> const& descriptions ) override;
+++ /**
+++ * Provides a simple default listing of listeners
+++ *
+++ * Looks similarly to listing of reporters, but with listener type
+++ * instead of reporter name.
+++ */
+++ void listListeners(
+++ std::vector<ListenerDescription> const& descriptions ) override;
+++ /**
+++ * Provides a simple default listing of tests.
+++ *
+++ * Should look roughly like the test listing in v2 and earlier versions
+++ * of Catch2. Especially supports low-verbosity listing that mimics the
+++ * old `--list-test-names-only` output.
+++ */
+++ void listTests( std::vector<TestCaseHandle> const& tests ) override;
+++ /**
+++ * Provides a simple default listing of tags.
+++ *
+++ * Should look roughly like the tag listing in v2 and earlier versions
+++ * of Catch2.
+++ */
+++ void listTags( std::vector<TagInfo> const& tags ) override;
+++ };
+++} // namespace Catch
+++
+++#endif // CATCH_REPORTER_COMMON_BASE_HPP_INCLUDED
+++
+++#include <vector>
+++
+++namespace Catch {
+++
+++ class StreamingReporterBase : public ReporterBase {
+++ public:
+++ // GCC5 compat: we cannot use inherited constructor, because it
+++ // doesn't implement backport of P0136
+++ StreamingReporterBase(ReporterConfig&& _config):
+++ ReporterBase(CATCH_MOVE(_config))
+++ {}
+++ ~StreamingReporterBase() override;
+++
+++ void benchmarkPreparing( StringRef ) override {}
+++ void benchmarkStarting( BenchmarkInfo const& ) override {}
+++ void benchmarkEnded( BenchmarkStats<> const& ) override {}
+++ void benchmarkFailed( StringRef ) override {}
+++
+++ void fatalErrorEncountered( StringRef /*error*/ ) override {}
+++ void noMatchingTestCases( StringRef /*unmatchedSpec*/ ) override {}
+++ void reportInvalidTestSpec( StringRef /*invalidArgument*/ ) override {}
+++
+++ void testRunStarting( TestRunInfo const& _testRunInfo ) override;
+++
+++ void testCaseStarting(TestCaseInfo const& _testInfo) override {
+++ currentTestCaseInfo = &_testInfo;
+++ }
+++ void testCasePartialStarting( TestCaseInfo const&, uint64_t ) override {}
+++ void sectionStarting(SectionInfo const& _sectionInfo) override {
+++ m_sectionStack.push_back(_sectionInfo);
+++ }
+++
+++ void assertionStarting( AssertionInfo const& ) override {}
+++ void assertionEnded( AssertionStats const& ) override {}
+++
+++ void sectionEnded(SectionStats const& /* _sectionStats */) override {
+++ m_sectionStack.pop_back();
+++ }
+++ void testCasePartialEnded( TestCaseStats const&, uint64_t ) override {}
+++ void testCaseEnded(TestCaseStats const& /* _testCaseStats */) override {
+++ currentTestCaseInfo = nullptr;
+++ }
+++ void testRunEnded( TestRunStats const& /* _testRunStats */ ) override;
+++
+++ void skipTest(TestCaseInfo const&) override {
+++ // Don't do anything with this by default.
+++ // It can optionally be overridden in the derived class.
+++ }
+++
+++ protected:
+++ TestRunInfo currentTestRunInfo{ "test run has not started yet"_sr };
+++ TestCaseInfo const* currentTestCaseInfo = nullptr;
+++
+++ //! Stack of all _active_ sections in the _current_ test case
+++ std::vector<SectionInfo> m_sectionStack;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_REPORTER_STREAMING_BASE_HPP_INCLUDED
+++
+++#include <string>
+++
+++namespace Catch {
+++
+++ class AutomakeReporter final : public StreamingReporterBase {
+++ public:
+++ // GCC5 compat: we cannot use inherited constructor, because it
+++ // doesn't implement backport of P0136
+++ AutomakeReporter(ReporterConfig&& _config):
+++ StreamingReporterBase(CATCH_MOVE(_config))
+++ {}
+++ ~AutomakeReporter() override;
+++
+++ static std::string getDescription() {
+++ using namespace std::string_literals;
+++ return "Reports test results in the format of Automake .trs files"s;
+++ }
+++
+++ void testCaseEnded(TestCaseStats const& _testCaseStats) override;
+++ void skipTest(TestCaseInfo const& testInfo) override;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_REPORTER_AUTOMAKE_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_REPORTER_COMPACT_HPP_INCLUDED
+++#define CATCH_REPORTER_COMPACT_HPP_INCLUDED
+++
+++
+++
+++
+++namespace Catch {
+++
+++ class CompactReporter final : public StreamingReporterBase {
+++ public:
+++ using StreamingReporterBase::StreamingReporterBase;
+++
+++ ~CompactReporter() override;
+++
+++ static std::string getDescription();
+++
+++ void noMatchingTestCases( StringRef unmatchedSpec ) override;
+++
+++ void testRunStarting( TestRunInfo const& _testInfo ) override;
+++
+++ void assertionEnded(AssertionStats const& _assertionStats) override;
+++
+++ void sectionEnded(SectionStats const& _sectionStats) override;
+++
+++ void testRunEnded(TestRunStats const& _testRunStats) override;
+++
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_REPORTER_COMPACT_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+++#define CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++ // Fwd decls
+++ class TablePrinter;
+++
+++ class ConsoleReporter final : public StreamingReporterBase {
+++ Detail::unique_ptr<TablePrinter> m_tablePrinter;
+++
+++ public:
+++ ConsoleReporter(ReporterConfig&& config);
+++ ~ConsoleReporter() override;
+++ static std::string getDescription();
+++
+++ void noMatchingTestCases( StringRef unmatchedSpec ) override;
+++ void reportInvalidTestSpec( StringRef arg ) override;
+++
+++ void assertionStarting(AssertionInfo const&) override;
+++
+++ void assertionEnded(AssertionStats const& _assertionStats) override;
+++
+++ void sectionStarting(SectionInfo const& _sectionInfo) override;
+++ void sectionEnded(SectionStats const& _sectionStats) override;
+++
+++ void benchmarkPreparing( StringRef name ) override;
+++ void benchmarkStarting(BenchmarkInfo const& info) override;
+++ void benchmarkEnded(BenchmarkStats<> const& stats) override;
+++ void benchmarkFailed( StringRef error ) override;
+++
+++ void testCaseEnded(TestCaseStats const& _testCaseStats) override;
+++ void testRunEnded(TestRunStats const& _testRunStats) override;
+++ void testRunStarting(TestRunInfo const& _testRunInfo) override;
+++
+++ private:
+++ void lazyPrint();
+++
+++ void lazyPrintWithoutClosingBenchmarkTable();
+++ void lazyPrintRunInfo();
+++ void printTestCaseAndSectionHeader();
+++
+++ void printClosedHeader(std::string const& _name);
+++ void printOpenHeader(std::string const& _name);
+++
+++ // if string has a : in first line will set indent to follow it on
+++ // subsequent lines
+++ void printHeaderString(std::string const& _string, std::size_t indent = 0);
+++
+++ void printTotalsDivider(Totals const& totals);
+++
+++ bool m_headerPrinted = false;
+++ bool m_testRunInfoPrinted = false;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_REPORTER_CONSOLE_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
+++#define CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
+++
+++
+++#include <string>
+++#include <vector>
+++
+++namespace Catch {
+++
+++ namespace Detail {
+++
+++ //! Represents either an assertion or a benchmark result to be handled by cumulative reporter later
+++ class AssertionOrBenchmarkResult {
+++ // This should really be a variant, but this is much faster
+++ // to write and the data layout here is already terrible
+++ // enough that we do not have to care about the object size.
+++ Optional<AssertionStats> m_assertion;
+++ Optional<BenchmarkStats<>> m_benchmark;
+++ public:
+++ AssertionOrBenchmarkResult(AssertionStats const& assertion);
+++ AssertionOrBenchmarkResult(BenchmarkStats<> const& benchmark);
+++
+++ bool isAssertion() const;
+++ bool isBenchmark() const;
+++
+++ AssertionStats const& asAssertion() const;
+++ BenchmarkStats<> const& asBenchmark() const;
+++ };
+++ }
+++
+++ /**
+++ * Utility base for reporters that need to handle all results at once
+++ *
+++ * It stores tree of all test cases, sections and assertions, and after the
+++ * test run is finished, calls into `testRunEndedCumulative` to pass the
+++ * control to the deriving class.
+++ *
+++ * If you are deriving from this class and override any testing related
+++ * member functions, you should first call into the base's implementation to
+++ * avoid breaking the tree construction.
+++ *
+++ * Due to the way this base functions, it has to expand assertions up-front,
+++ * even if they are later unused (e.g. because the deriving reporter does
+++ * not report successful assertions, or because the deriving reporter does
+++ * not use assertion expansion at all). Derived classes can use two
+++ * customization points, `m_shouldStoreSuccesfulAssertions` and
+++ * `m_shouldStoreFailedAssertions`, to disable the expansion and gain extra
+++ * performance. **Accessing the assertion expansions if it wasn't stored is
+++ * UB.**
+++ */
+++ class CumulativeReporterBase : public ReporterBase {
+++ public:
+++ template<typename T, typename ChildNodeT>
+++ struct Node {
+++ explicit Node( T const& _value ) : value( _value ) {}
+++
+++ using ChildNodes = std::vector<Detail::unique_ptr<ChildNodeT>>;
+++ T value;
+++ ChildNodes children;
+++ };
+++ struct SectionNode {
+++ explicit SectionNode(SectionStats const& _stats) : stats(_stats) {}
+++
+++ bool operator == (SectionNode const& other) const {
+++ return stats.sectionInfo.lineInfo == other.stats.sectionInfo.lineInfo;
+++ }
+++
+++ bool hasAnyAssertions() const;
+++
+++ SectionStats stats;
+++ std::vector<Detail::unique_ptr<SectionNode>> childSections;
+++ std::vector<Detail::AssertionOrBenchmarkResult> assertionsAndBenchmarks;
+++ std::string stdOut;
+++ std::string stdErr;
+++ };
+++
+++
+++ using TestCaseNode = Node<TestCaseStats, SectionNode>;
+++ using TestRunNode = Node<TestRunStats, TestCaseNode>;
+++
+++ // GCC5 compat: we cannot use inherited constructor, because it
+++ // doesn't implement backport of P0136
+++ CumulativeReporterBase(ReporterConfig&& _config):
+++ ReporterBase(CATCH_MOVE(_config))
+++ {}
+++ ~CumulativeReporterBase() override;
+++
+++ void benchmarkPreparing( StringRef ) override {}
+++ void benchmarkStarting( BenchmarkInfo const& ) override {}
+++ void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+++ void benchmarkFailed( StringRef ) override {}
+++
+++ void noMatchingTestCases( StringRef ) override {}
+++ void reportInvalidTestSpec( StringRef ) override {}
+++ void fatalErrorEncountered( StringRef /*error*/ ) override {}
+++
+++ void testRunStarting( TestRunInfo const& ) override {}
+++
+++ void testCaseStarting( TestCaseInfo const& ) override {}
+++ void testCasePartialStarting( TestCaseInfo const&, uint64_t ) override {}
+++ void sectionStarting( SectionInfo const& sectionInfo ) override;
+++
+++ void assertionStarting( AssertionInfo const& ) override {}
+++
+++ void assertionEnded( AssertionStats const& assertionStats ) override;
+++ void sectionEnded( SectionStats const& sectionStats ) override;
+++ void testCasePartialEnded( TestCaseStats const&, uint64_t ) override {}
+++ void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+++ void testRunEnded( TestRunStats const& testRunStats ) override;
+++ //! Customization point: called after last test finishes (testRunEnded has been handled)
+++ virtual void testRunEndedCumulative() = 0;
+++
+++ void skipTest(TestCaseInfo const&) override {}
+++
+++ protected:
+++ //! Should the cumulative base store the assertion expansion for successful assertions?
+++ bool m_shouldStoreSuccesfulAssertions = true;
+++ //! Should the cumulative base store the assertion expansion for failed assertions?
+++ bool m_shouldStoreFailedAssertions = true;
+++
+++ // We need lazy construction here. We should probably refactor it
+++ // later, after the events are redone.
+++ //! The root node of the test run tree.
+++ Detail::unique_ptr<TestRunNode> m_testRun;
+++
+++ private:
+++ // Note: We rely on pointer identity being stable, which is why
+++ // we store pointers to the nodes rather than the values.
+++ std::vector<Detail::unique_ptr<TestCaseNode>> m_testCases;
+++ // Root section of the _current_ test case
+++ Detail::unique_ptr<SectionNode> m_rootSection;
+++ // Deepest section of the _current_ test case
+++ SectionNode* m_deepestSection = nullptr;
+++ // Stack of _active_ sections in the _current_ test case
+++ std::vector<SectionNode*> m_sectionStack;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_REPORTER_CUMULATIVE_BASE_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
+++#define CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++
+++ /**
+++ * Base class to simplify implementing listeners.
+++ *
+++ * Provides empty default implementation for all IEventListener member
+++ * functions, so that a listener implementation can pick which
+++ * member functions it actually cares about.
+++ */
+++ class EventListenerBase : public IEventListener {
+++ public:
+++ using IEventListener::IEventListener;
+++
+++ void reportInvalidTestSpec( StringRef unmatchedSpec ) override;
+++ void fatalErrorEncountered( StringRef error ) override;
+++
+++ void benchmarkPreparing( StringRef name ) override;
+++ void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
+++ void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+++ void benchmarkFailed( StringRef error ) override;
+++
+++ void assertionStarting( AssertionInfo const& assertionInfo ) override;
+++ void assertionEnded( AssertionStats const& assertionStats ) override;
+++
+++ void listReporters(
+++ std::vector<ReporterDescription> const& descriptions ) override;
+++ void listListeners(
+++ std::vector<ListenerDescription> const& descriptions ) override;
+++ void listTests( std::vector<TestCaseHandle> const& tests ) override;
+++ void listTags( std::vector<TagInfo> const& tagInfos ) override;
+++
+++ void noMatchingTestCases( StringRef unmatchedSpec ) override;
+++ void testRunStarting( TestRunInfo const& testRunInfo ) override;
+++ void testCaseStarting( TestCaseInfo const& testInfo ) override;
+++ void testCasePartialStarting( TestCaseInfo const& testInfo,
+++ uint64_t partNumber ) override;
+++ void sectionStarting( SectionInfo const& sectionInfo ) override;
+++ void sectionEnded( SectionStats const& sectionStats ) override;
+++ void testCasePartialEnded( TestCaseStats const& testCaseStats,
+++ uint64_t partNumber ) override;
+++ void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+++ void testRunEnded( TestRunStats const& testRunStats ) override;
+++ void skipTest( TestCaseInfo const& testInfo ) override;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_REPORTER_EVENT_LISTENER_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_REPORTER_HELPERS_HPP_INCLUDED
+++#define CATCH_REPORTER_HELPERS_HPP_INCLUDED
+++
+++#include <iosfwd>
+++#include <string>
+++#include <vector>
+++
+++
+++namespace Catch {
+++
+++ class IConfig;
+++ class TestCaseHandle;
+++ class ColourImpl;
+++
+++ // Returns double formatted as %.3f (format expected on output)
+++ std::string getFormattedDuration( double duration );
+++
+++ //! Should the reporter show duration of test given current configuration?
+++ bool shouldShowDuration( IConfig const& config, double duration );
+++
+++ std::string serializeFilters( std::vector<std::string> const& filters );
+++
+++ struct lineOfChars {
+++ char c;
+++ constexpr lineOfChars( char c_ ): c( c_ ) {}
+++
+++ friend std::ostream& operator<<( std::ostream& out, lineOfChars value );
+++ };
+++
+++ /**
+++ * Lists reporter descriptions to the provided stream in user-friendly
+++ * format
+++ *
+++ * Used as the default listing implementation by the first party reporter
+++ * bases. The output should be backwards compatible with the output of
+++ * Catch2 v2 binaries.
+++ */
+++ void
+++ defaultListReporters( std::ostream& out,
+++ std::vector<ReporterDescription> const& descriptions,
+++ Verbosity verbosity );
+++
+++ /**
+++ * Lists listeners descriptions to the provided stream in user-friendly
+++ * format
+++ */
+++ void defaultListListeners( std::ostream& out,
+++ std::vector<ListenerDescription> const& descriptions );
+++
+++ /**
+++ * Lists tag information to the provided stream in user-friendly format
+++ *
+++ * Used as the default listing implementation by the first party reporter
+++ * bases. The output should be backwards compatible with the output of
+++ * Catch2 v2 binaries.
+++ */
+++ void defaultListTags( std::ostream& out, std::vector<TagInfo> const& tags, bool isFiltered );
+++
+++ /**
+++ * Lists test case information to the provided stream in user-friendly
+++ * format
+++ *
+++ * Used as the default listing implementation by the first party reporter
+++ * bases. The output is backwards compatible with the output of Catch2
+++ * v2 binaries, and also supports the format specific to the old
+++ * `--list-test-names-only` option, for people who used it in integrations.
+++ */
+++ void defaultListTests( std::ostream& out,
+++ ColourImpl* streamColour,
+++ std::vector<TestCaseHandle> const& tests,
+++ bool isFiltered,
+++ Verbosity verbosity );
+++
+++ /**
+++ * Prints test run totals to the provided stream in user-friendly format
+++ *
+++ * Used by the console and compact reporters.
+++ */
+++ void printTestRunTotals( std::ostream& stream,
+++ ColourImpl& streamColour,
+++ Totals const& totals );
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_REPORTER_HELPERS_HPP_INCLUDED
+++
+++
+++
+++#ifndef CATCH_REPORTER_JSON_HPP_INCLUDED
+++#define CATCH_REPORTER_JSON_HPP_INCLUDED
+++
+++
+++#include <stack>
+++
+++namespace Catch {
+++ class JsonReporter : public StreamingReporterBase {
+++ public:
+++ JsonReporter( ReporterConfig&& config );
+++
+++ ~JsonReporter() override;
+++
+++ static std::string getDescription();
+++
+++ public: // StreamingReporterBase
+++ void testRunStarting( TestRunInfo const& runInfo ) override;
+++ void testRunEnded( TestRunStats const& runStats ) override;
+++
+++ void testCaseStarting( TestCaseInfo const& tcInfo ) override;
+++ void testCaseEnded( TestCaseStats const& tcStats ) override;
+++
+++ void testCasePartialStarting( TestCaseInfo const& tcInfo,
+++ uint64_t index ) override;
+++ void testCasePartialEnded( TestCaseStats const& tcStats,
+++ uint64_t index ) override;
+++
+++ void sectionStarting( SectionInfo const& sectionInfo ) override;
+++ void sectionEnded( SectionStats const& sectionStats ) override;
+++
+++ void assertionStarting( AssertionInfo const& assertionInfo ) override;
+++ void assertionEnded( AssertionStats const& assertionStats ) override;
+++
+++ //void testRunEndedCumulative() override;
+++
+++ void benchmarkPreparing( StringRef name ) override;
+++ void benchmarkStarting( BenchmarkInfo const& ) override;
+++ void benchmarkEnded( BenchmarkStats<> const& ) override;
+++ void benchmarkFailed( StringRef error ) override;
+++
+++ void listReporters(
+++ std::vector<ReporterDescription> const& descriptions ) override;
+++ void listListeners(
+++ std::vector<ListenerDescription> const& descriptions ) override;
+++ void listTests( std::vector<TestCaseHandle> const& tests ) override;
+++ void listTags( std::vector<TagInfo> const& tags ) override;
+++
+++ private:
+++ Timer m_testCaseTimer;
+++ enum class Writer {
+++ Object,
+++ Array
+++ };
+++
+++ JsonArrayWriter& startArray();
+++ JsonArrayWriter& startArray( StringRef key );
+++
+++ JsonObjectWriter& startObject();
+++ JsonObjectWriter& startObject( StringRef key );
+++
+++ void endObject();
+++ void endArray();
+++
+++ bool isInside( Writer writer );
+++
+++ void startListing();
+++ void endListing();
+++
+++ // Invariant:
+++ // When m_writers is not empty and its top element is
+++ // - Writer::Object, then m_objectWriters is not be empty
+++ // - Writer::Array, then m_arrayWriters shall not be empty
+++ std::stack<JsonObjectWriter> m_objectWriters{};
+++ std::stack<JsonArrayWriter> m_arrayWriters{};
+++ std::stack<Writer> m_writers{};
+++
+++ bool m_startedListing = false;
+++
+++ // std::size_t m_sectionDepth = 0;
+++ // std::size_t m_sectionStarted = 0;
+++ };
+++} // namespace Catch
+++
+++#endif // CATCH_REPORTER_JSON_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_REPORTER_JUNIT_HPP_INCLUDED
+++#define CATCH_REPORTER_JUNIT_HPP_INCLUDED
+++
+++
+++
+++namespace Catch {
+++
+++ class JunitReporter final : public CumulativeReporterBase {
+++ public:
+++ JunitReporter(ReporterConfig&& _config);
+++
+++ static std::string getDescription();
+++
+++ void testRunStarting(TestRunInfo const& runInfo) override;
+++
+++ void testCaseStarting(TestCaseInfo const& testCaseInfo) override;
+++ void assertionEnded(AssertionStats const& assertionStats) override;
+++
+++ void testCaseEnded(TestCaseStats const& testCaseStats) override;
+++
+++ void testRunEndedCumulative() override;
+++
+++ private:
+++ void writeRun(TestRunNode const& testRunNode, double suiteTime);
+++
+++ void writeTestCase(TestCaseNode const& testCaseNode);
+++
+++ void writeSection( std::string const& className,
+++ std::string const& rootName,
+++ SectionNode const& sectionNode,
+++ bool testOkToFail );
+++
+++ void writeAssertions(SectionNode const& sectionNode);
+++ void writeAssertion(AssertionStats const& stats);
+++
+++ XmlWriter xml;
+++ Timer suiteTimer;
+++ std::string stdOutForSuite;
+++ std::string stdErrForSuite;
+++ unsigned int unexpectedExceptions = 0;
+++ bool m_okToFail = false;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_REPORTER_JUNIT_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_REPORTER_MULTI_HPP_INCLUDED
+++#define CATCH_REPORTER_MULTI_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++
+++ class MultiReporter final : public IEventListener {
+++ /*
+++ * Stores all added reporters and listeners
+++ *
+++ * All Listeners are stored before all reporters, and individual
+++ * listeners/reporters are stored in order of insertion.
+++ */
+++ std::vector<IEventListenerPtr> m_reporterLikes;
+++ bool m_haveNoncapturingReporters = false;
+++
+++ // Keep track of how many listeners we have already inserted,
+++ // so that we can insert them into the main vector at the right place
+++ size_t m_insertedListeners = 0;
+++
+++ void updatePreferences(IEventListener const& reporterish);
+++
+++ public:
+++ using IEventListener::IEventListener;
+++
+++ void addListener( IEventListenerPtr&& listener );
+++ void addReporter( IEventListenerPtr&& reporter );
+++
+++ public: // IEventListener
+++
+++ void noMatchingTestCases( StringRef unmatchedSpec ) override;
+++ void fatalErrorEncountered( StringRef error ) override;
+++ void reportInvalidTestSpec( StringRef arg ) override;
+++
+++ void benchmarkPreparing( StringRef name ) override;
+++ void benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) override;
+++ void benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) override;
+++ void benchmarkFailed( StringRef error ) override;
+++
+++ void testRunStarting( TestRunInfo const& testRunInfo ) override;
+++ void testCaseStarting( TestCaseInfo const& testInfo ) override;
+++ void testCasePartialStarting(TestCaseInfo const& testInfo, uint64_t partNumber) override;
+++ void sectionStarting( SectionInfo const& sectionInfo ) override;
+++ void assertionStarting( AssertionInfo const& assertionInfo ) override;
+++
+++ void assertionEnded( AssertionStats const& assertionStats ) override;
+++ void sectionEnded( SectionStats const& sectionStats ) override;
+++ void testCasePartialEnded(TestCaseStats const& testStats, uint64_t partNumber) override;
+++ void testCaseEnded( TestCaseStats const& testCaseStats ) override;
+++ void testRunEnded( TestRunStats const& testRunStats ) override;
+++
+++ void skipTest( TestCaseInfo const& testInfo ) override;
+++
+++ void listReporters(std::vector<ReporterDescription> const& descriptions) override;
+++ void listListeners(std::vector<ListenerDescription> const& descriptions) override;
+++ void listTests(std::vector<TestCaseHandle> const& tests) override;
+++ void listTags(std::vector<TagInfo> const& tags) override;
+++
+++
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_REPORTER_MULTI_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+++#define CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+++
+++
+++#include <type_traits>
+++
+++namespace Catch {
+++
+++ namespace Detail {
+++
+++ template <typename T, typename = void>
+++ struct has_description : std::false_type {};
+++
+++ template <typename T>
+++ struct has_description<
+++ T,
+++ void_t<decltype( T::getDescription() )>>
+++ : std::true_type {};
+++
+++ //! Indirection for reporter registration, so that the error handling is
+++ //! independent on the reporter's concrete type
+++ void registerReporterImpl( std::string const& name,
+++ IReporterFactoryPtr reporterPtr );
+++ //! Actually registers the factory, independent on listener's concrete type
+++ void registerListenerImpl( Detail::unique_ptr<EventListenerFactory> listenerFactory );
+++ } // namespace Detail
+++
+++ class IEventListener;
+++ using IEventListenerPtr = Detail::unique_ptr<IEventListener>;
+++
+++ template <typename T>
+++ class ReporterFactory : public IReporterFactory {
+++
+++ IEventListenerPtr create( ReporterConfig&& config ) const override {
+++ return Detail::make_unique<T>( CATCH_MOVE(config) );
+++ }
+++
+++ std::string getDescription() const override {
+++ return T::getDescription();
+++ }
+++ };
+++
+++
+++ template<typename T>
+++ class ReporterRegistrar {
+++ public:
+++ explicit ReporterRegistrar( std::string const& name ) {
+++ registerReporterImpl( name,
+++ Detail::make_unique<ReporterFactory<T>>() );
+++ }
+++ };
+++
+++ template<typename T>
+++ class ListenerRegistrar {
+++
+++ class TypedListenerFactory : public EventListenerFactory {
+++ StringRef m_listenerName;
+++
+++ std::string getDescriptionImpl( std::true_type ) const {
+++ return T::getDescription();
+++ }
+++
+++ std::string getDescriptionImpl( std::false_type ) const {
+++ return "(No description provided)";
+++ }
+++
+++ public:
+++ TypedListenerFactory( StringRef listenerName ):
+++ m_listenerName( listenerName ) {}
+++
+++ IEventListenerPtr create( IConfig const* config ) const override {
+++ return Detail::make_unique<T>( config );
+++ }
+++
+++ StringRef getName() const override {
+++ return m_listenerName;
+++ }
+++
+++ std::string getDescription() const override {
+++ return getDescriptionImpl( Detail::has_description<T>{} );
+++ }
+++ };
+++
+++ public:
+++ ListenerRegistrar(StringRef listenerName) {
+++ registerListenerImpl( Detail::make_unique<TypedListenerFactory>(listenerName) );
+++ }
+++ };
+++}
+++
+++#if !defined(CATCH_CONFIG_DISABLE)
+++
+++# define CATCH_REGISTER_REPORTER( name, reporterType ) \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+++ namespace { \
+++ Catch::ReporterRegistrar<reporterType> INTERNAL_CATCH_UNIQUE_NAME( \
+++ catch_internal_RegistrarFor )( name ); \
+++ } \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+++
+++# define CATCH_REGISTER_LISTENER( listenerType ) \
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION \
+++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS \
+++ namespace { \
+++ Catch::ListenerRegistrar<listenerType> INTERNAL_CATCH_UNIQUE_NAME( \
+++ catch_internal_RegistrarFor )( #listenerType##_catch_sr ); \
+++ } \
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+++
+++#else // CATCH_CONFIG_DISABLE
+++
+++#define CATCH_REGISTER_REPORTER(name, reporterType)
+++#define CATCH_REGISTER_LISTENER(listenerType)
+++
+++#endif // CATCH_CONFIG_DISABLE
+++
+++#endif // CATCH_REPORTER_REGISTRARS_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+++#define CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+++
+++
+++
+++namespace Catch {
+++
+++ class SonarQubeReporter final : public CumulativeReporterBase {
+++ public:
+++ SonarQubeReporter(ReporterConfig&& config)
+++ : CumulativeReporterBase(CATCH_MOVE(config))
+++ , xml(m_stream) {
+++ m_preferences.shouldRedirectStdOut = true;
+++ m_preferences.shouldReportAllAssertions = true;
+++ m_shouldStoreSuccesfulAssertions = false;
+++ }
+++
+++ static std::string getDescription() {
+++ using namespace std::string_literals;
+++ return "Reports test results in the Generic Test Data SonarQube XML format"s;
+++ }
+++
+++ void testRunStarting( TestRunInfo const& testRunInfo ) override;
+++
+++ void testRunEndedCumulative() override {
+++ writeRun( *m_testRun );
+++ xml.endElement();
+++ }
+++
+++ void writeRun( TestRunNode const& runNode );
+++
+++ void writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes);
+++
+++ void writeTestCase(TestCaseNode const& testCaseNode);
+++
+++ void writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail);
+++
+++ void writeAssertions(SectionNode const& sectionNode, bool okToFail);
+++
+++ void writeAssertion(AssertionStats const& stats, bool okToFail);
+++
+++ private:
+++ XmlWriter xml;
+++ };
+++
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_REPORTER_SONARQUBE_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_REPORTER_TAP_HPP_INCLUDED
+++#define CATCH_REPORTER_TAP_HPP_INCLUDED
+++
+++
+++namespace Catch {
+++
+++ class TAPReporter final : public StreamingReporterBase {
+++ public:
+++ TAPReporter( ReporterConfig&& config ):
+++ StreamingReporterBase( CATCH_MOVE(config) ) {
+++ m_preferences.shouldReportAllAssertions = true;
+++ }
+++
+++ static std::string getDescription() {
+++ using namespace std::string_literals;
+++ return "Reports test results in TAP format, suitable for test harnesses"s;
+++ }
+++
+++ void testRunStarting( TestRunInfo const& testInfo ) override;
+++
+++ void noMatchingTestCases( StringRef unmatchedSpec ) override;
+++
+++ void assertionEnded(AssertionStats const& _assertionStats) override;
+++
+++ void testRunEnded(TestRunStats const& _testRunStats) override;
+++
+++ private:
+++ std::size_t counter = 0;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_REPORTER_TAP_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+++#define CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+++
+++
+++#include <cstring>
+++
+++#ifdef __clang__
+++# pragma clang diagnostic push
+++# pragma clang diagnostic ignored "-Wpadded"
+++#endif
+++
+++namespace Catch {
+++
+++ class TeamCityReporter final : public StreamingReporterBase {
+++ public:
+++ TeamCityReporter( ReporterConfig&& _config )
+++ : StreamingReporterBase( CATCH_MOVE(_config) )
+++ {
+++ m_preferences.shouldRedirectStdOut = true;
+++ }
+++
+++ ~TeamCityReporter() override;
+++
+++ static std::string getDescription() {
+++ using namespace std::string_literals;
+++ return "Reports test results as TeamCity service messages"s;
+++ }
+++
+++ void testRunStarting( TestRunInfo const& runInfo ) override;
+++ void testRunEnded( TestRunStats const& runStats ) override;
+++
+++
+++ void assertionEnded(AssertionStats const& assertionStats) override;
+++
+++ void sectionStarting(SectionInfo const& sectionInfo) override {
+++ m_headerPrintedForThisSection = false;
+++ StreamingReporterBase::sectionStarting( sectionInfo );
+++ }
+++
+++ void testCaseStarting(TestCaseInfo const& testInfo) override;
+++
+++ void testCaseEnded(TestCaseStats const& testCaseStats) override;
+++
+++ private:
+++ void printSectionHeader(std::ostream& os);
+++
+++ bool m_headerPrintedForThisSection = false;
+++ Timer m_testTimer;
+++ };
+++
+++} // end namespace Catch
+++
+++#ifdef __clang__
+++# pragma clang diagnostic pop
+++#endif
+++
+++#endif // CATCH_REPORTER_TEAMCITY_HPP_INCLUDED
+++
+++
+++#ifndef CATCH_REPORTER_XML_HPP_INCLUDED
+++#define CATCH_REPORTER_XML_HPP_INCLUDED
+++
+++
+++
+++
+++namespace Catch {
+++ class XmlReporter : public StreamingReporterBase {
+++ public:
+++ XmlReporter(ReporterConfig&& _config);
+++
+++ ~XmlReporter() override;
+++
+++ static std::string getDescription();
+++
+++ virtual std::string getStylesheetRef() const;
+++
+++ void writeSourceInfo(SourceLineInfo const& sourceInfo);
+++
+++ public: // StreamingReporterBase
+++
+++ void testRunStarting(TestRunInfo const& testInfo) override;
+++
+++ void testCaseStarting(TestCaseInfo const& testInfo) override;
+++
+++ void sectionStarting(SectionInfo const& sectionInfo) override;
+++
+++ void assertionStarting(AssertionInfo const&) override;
+++
+++ void assertionEnded(AssertionStats const& assertionStats) override;
+++
+++ void sectionEnded(SectionStats const& sectionStats) override;
+++
+++ void testCaseEnded(TestCaseStats const& testCaseStats) override;
+++
+++ void testRunEnded(TestRunStats const& testRunStats) override;
+++
+++ void benchmarkPreparing( StringRef name ) override;
+++ void benchmarkStarting(BenchmarkInfo const&) override;
+++ void benchmarkEnded(BenchmarkStats<> const&) override;
+++ void benchmarkFailed( StringRef error ) override;
+++
+++ void listReporters(std::vector<ReporterDescription> const& descriptions) override;
+++ void listListeners(std::vector<ListenerDescription> const& descriptions) override;
+++ void listTests(std::vector<TestCaseHandle> const& tests) override;
+++ void listTags(std::vector<TagInfo> const& tags) override;
+++
+++ private:
+++ Timer m_testCaseTimer;
+++ XmlWriter m_xml;
+++ int m_sectionDepth = 0;
+++ };
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_REPORTER_XML_HPP_INCLUDED
+++
+++#endif // CATCH_REPORTERS_ALL_HPP_INCLUDED
+++
+++#endif // CATCH_ALL_HPP_INCLUDED
+++#endif // CATCH_AMALGAMATED_HPP_INCLUDED
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/main.cpp
++@@ -0,0 +1,11638 @@
+++
+++// Copyright Catch2 Authors
+++// Distributed under the Boost Software License, Version 1.0.
+++// (See accompanying file LICENSE.txt or copy at
+++// https://www.boost.org/LICENSE_1_0.txt)
+++
+++// SPDX-License-Identifier: BSL-1.0
+++
+++// Catch v3.6.0
+++// Generated: 2024-05-05 20:53:27.562886
+++// ----------------------------------------------------------
+++// This file is an amalgamation of multiple different files.
+++// You probably shouldn't edit it directly.
+++// ----------------------------------------------------------
+++
+++#include "catch.hpp"
+++
+++
+++#ifndef CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
+++#define CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
+++
+++
+++#if defined(CATCH_PLATFORM_WINDOWS)
+++
+++// We might end up with the define made globally through the compiler,
+++// and we don't want to trigger warnings for this
+++#if !defined(NOMINMAX)
+++# define NOMINMAX
+++#endif
+++#if !defined(WIN32_LEAN_AND_MEAN)
+++# define WIN32_LEAN_AND_MEAN
+++#endif
+++
+++#include <windows.h>
+++
+++#endif // defined(CATCH_PLATFORM_WINDOWS)
+++
+++#endif // CATCH_WINDOWS_H_PROXY_HPP_INCLUDED
+++
+++
+++
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ namespace Detail {
+++ ChronometerConcept::~ChronometerConcept() = default;
+++ } // namespace Detail
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++
+++// Adapted from donated nonius code.
+++
+++
+++#include <vector>
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ namespace Detail {
+++ SampleAnalysis analyse(const IConfig &cfg, FDuration* first, FDuration* last) {
+++ if (!cfg.benchmarkNoAnalysis()) {
+++ std::vector<double> samples;
+++ samples.reserve(static_cast<size_t>(last - first));
+++ for (auto current = first; current != last; ++current) {
+++ samples.push_back( current->count() );
+++ }
+++
+++ auto analysis = Catch::Benchmark::Detail::analyse_samples(
+++ cfg.benchmarkConfidenceInterval(),
+++ cfg.benchmarkResamples(),
+++ samples.data(),
+++ samples.data() + samples.size() );
+++ auto outliers = Catch::Benchmark::Detail::classify_outliers(
+++ samples.data(), samples.data() + samples.size() );
+++
+++ auto wrap_estimate = [](Estimate<double> e) {
+++ return Estimate<FDuration> {
+++ FDuration(e.point),
+++ FDuration(e.lower_bound),
+++ FDuration(e.upper_bound),
+++ e.confidence_interval,
+++ };
+++ };
+++ std::vector<FDuration> samples2;
+++ samples2.reserve(samples.size());
+++ for (auto s : samples) {
+++ samples2.push_back( FDuration( s ) );
+++ }
+++
+++ return {
+++ CATCH_MOVE(samples2),
+++ wrap_estimate(analysis.mean),
+++ wrap_estimate(analysis.standard_deviation),
+++ outliers,
+++ analysis.outlier_variance,
+++ };
+++ } else {
+++ std::vector<FDuration> samples;
+++ samples.reserve(static_cast<size_t>(last - first));
+++
+++ FDuration mean = FDuration(0);
+++ int i = 0;
+++ for (auto it = first; it < last; ++it, ++i) {
+++ samples.push_back(*it);
+++ mean += *it;
+++ }
+++ mean /= i;
+++
+++ return SampleAnalysis{
+++ CATCH_MOVE(samples),
+++ Estimate<FDuration>{ mean, mean, mean, 0.0 },
+++ Estimate<FDuration>{ FDuration( 0 ),
+++ FDuration( 0 ),
+++ FDuration( 0 ),
+++ 0.0 },
+++ OutlierClassification{},
+++ 0.0
+++ };
+++ }
+++ }
+++ } // namespace Detail
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++
+++
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ namespace Detail {
+++ BenchmarkFunction::callable::~callable() = default;
+++ } // namespace Detail
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++
+++
+++
+++#include <exception>
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ namespace Detail {
+++ struct optimized_away_error : std::exception {
+++ const char* what() const noexcept override;
+++ };
+++
+++ const char* optimized_away_error::what() const noexcept {
+++ return "could not measure benchmark, maybe it was optimized away";
+++ }
+++
+++ void throw_optimized_away_error() {
+++ Catch::throw_exception(optimized_away_error{});
+++ }
+++
+++ } // namespace Detail
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++
+++// Adapted from donated nonius code.
+++
+++
+++
+++#include <algorithm>
+++#include <cassert>
+++#include <cmath>
+++#include <cstddef>
+++#include <numeric>
+++#include <random>
+++
+++
+++#if defined(CATCH_CONFIG_USE_ASYNC)
+++#include <future>
+++#endif
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ namespace Detail {
+++ namespace {
+++
+++ template <typename URng, typename Estimator>
+++ static sample
+++ resample( URng& rng,
+++ unsigned int resamples,
+++ double const* first,
+++ double const* last,
+++ Estimator& estimator ) {
+++ auto n = static_cast<size_t>( last - first );
+++ Catch::uniform_integer_distribution<size_t> dist( 0, n - 1 );
+++
+++ sample out;
+++ out.reserve( resamples );
+++ std::vector<double> resampled;
+++ resampled.reserve( n );
+++ for ( size_t i = 0; i < resamples; ++i ) {
+++ resampled.clear();
+++ for ( size_t s = 0; s < n; ++s ) {
+++ resampled.push_back( first[dist( rng )] );
+++ }
+++ const auto estimate =
+++ estimator( resampled.data(), resampled.data() + resampled.size() );
+++ out.push_back( estimate );
+++ }
+++ std::sort( out.begin(), out.end() );
+++ return out;
+++ }
+++
+++ static double outlier_variance( Estimate<double> mean,
+++ Estimate<double> stddev,
+++ int n ) {
+++ double sb = stddev.point;
+++ double mn = mean.point / n;
+++ double mg_min = mn / 2.;
+++ double sg = (std::min)( mg_min / 4., sb / std::sqrt( n ) );
+++ double sg2 = sg * sg;
+++ double sb2 = sb * sb;
+++
+++ auto c_max = [n, mn, sb2, sg2]( double x ) -> double {
+++ double k = mn - x;
+++ double d = k * k;
+++ double nd = n * d;
+++ double k0 = -n * nd;
+++ double k1 = sb2 - n * sg2 + nd;
+++ double det = k1 * k1 - 4 * sg2 * k0;
+++ return static_cast<int>( -2. * k0 /
+++ ( k1 + std::sqrt( det ) ) );
+++ };
+++
+++ auto var_out = [n, sb2, sg2]( double c ) {
+++ double nc = n - c;
+++ return ( nc / n ) * ( sb2 - nc * sg2 );
+++ };
+++
+++ return (std::min)( var_out( 1 ),
+++ var_out(
+++ (std::min)( c_max( 0. ),
+++ c_max( mg_min ) ) ) ) /
+++ sb2;
+++ }
+++
+++ static double erf_inv( double x ) {
+++ // Code accompanying the article "Approximating the erfinv
+++ // function" in GPU Computing Gems, Volume 2
+++ double w, p;
+++
+++ w = -log( ( 1.0 - x ) * ( 1.0 + x ) );
+++
+++ if ( w < 6.250000 ) {
+++ w = w - 3.125000;
+++ p = -3.6444120640178196996e-21;
+++ p = -1.685059138182016589e-19 + p * w;
+++ p = 1.2858480715256400167e-18 + p * w;
+++ p = 1.115787767802518096e-17 + p * w;
+++ p = -1.333171662854620906e-16 + p * w;
+++ p = 2.0972767875968561637e-17 + p * w;
+++ p = 6.6376381343583238325e-15 + p * w;
+++ p = -4.0545662729752068639e-14 + p * w;
+++ p = -8.1519341976054721522e-14 + p * w;
+++ p = 2.6335093153082322977e-12 + p * w;
+++ p = -1.2975133253453532498e-11 + p * w;
+++ p = -5.4154120542946279317e-11 + p * w;
+++ p = 1.051212273321532285e-09 + p * w;
+++ p = -4.1126339803469836976e-09 + p * w;
+++ p = -2.9070369957882005086e-08 + p * w;
+++ p = 4.2347877827932403518e-07 + p * w;
+++ p = -1.3654692000834678645e-06 + p * w;
+++ p = -1.3882523362786468719e-05 + p * w;
+++ p = 0.0001867342080340571352 + p * w;
+++ p = -0.00074070253416626697512 + p * w;
+++ p = -0.0060336708714301490533 + p * w;
+++ p = 0.24015818242558961693 + p * w;
+++ p = 1.6536545626831027356 + p * w;
+++ } else if ( w < 16.000000 ) {
+++ w = sqrt( w ) - 3.250000;
+++ p = 2.2137376921775787049e-09;
+++ p = 9.0756561938885390979e-08 + p * w;
+++ p = -2.7517406297064545428e-07 + p * w;
+++ p = 1.8239629214389227755e-08 + p * w;
+++ p = 1.5027403968909827627e-06 + p * w;
+++ p = -4.013867526981545969e-06 + p * w;
+++ p = 2.9234449089955446044e-06 + p * w;
+++ p = 1.2475304481671778723e-05 + p * w;
+++ p = -4.7318229009055733981e-05 + p * w;
+++ p = 6.8284851459573175448e-05 + p * w;
+++ p = 2.4031110387097893999e-05 + p * w;
+++ p = -0.0003550375203628474796 + p * w;
+++ p = 0.00095328937973738049703 + p * w;
+++ p = -0.0016882755560235047313 + p * w;
+++ p = 0.0024914420961078508066 + p * w;
+++ p = -0.0037512085075692412107 + p * w;
+++ p = 0.005370914553590063617 + p * w;
+++ p = 1.0052589676941592334 + p * w;
+++ p = 3.0838856104922207635 + p * w;
+++ } else {
+++ w = sqrt( w ) - 5.000000;
+++ p = -2.7109920616438573243e-11;
+++ p = -2.5556418169965252055e-10 + p * w;
+++ p = 1.5076572693500548083e-09 + p * w;
+++ p = -3.7894654401267369937e-09 + p * w;
+++ p = 7.6157012080783393804e-09 + p * w;
+++ p = -1.4960026627149240478e-08 + p * w;
+++ p = 2.9147953450901080826e-08 + p * w;
+++ p = -6.7711997758452339498e-08 + p * w;
+++ p = 2.2900482228026654717e-07 + p * w;
+++ p = -9.9298272942317002539e-07 + p * w;
+++ p = 4.5260625972231537039e-06 + p * w;
+++ p = -1.9681778105531670567e-05 + p * w;
+++ p = 7.5995277030017761139e-05 + p * w;
+++ p = -0.00021503011930044477347 + p * w;
+++ p = -0.00013871931833623122026 + p * w;
+++ p = 1.0103004648645343977 + p * w;
+++ p = 4.8499064014085844221 + p * w;
+++ }
+++ return p * x;
+++ }
+++
+++ static double
+++ standard_deviation( double const* first, double const* last ) {
+++ auto m = Catch::Benchmark::Detail::mean( first, last );
+++ double variance =
+++ std::accumulate( first,
+++ last,
+++ 0.,
+++ [m]( double a, double b ) {
+++ double diff = b - m;
+++ return a + diff * diff;
+++ } ) /
+++ ( last - first );
+++ return std::sqrt( variance );
+++ }
+++
+++ static sample jackknife( double ( *estimator )( double const*,
+++ double const* ),
+++ double* first,
+++ double* last ) {
+++ const auto second = first + 1;
+++ sample results;
+++ results.reserve( static_cast<size_t>( last - first ) );
+++
+++ for ( auto it = first; it != last; ++it ) {
+++ std::iter_swap( it, first );
+++ results.push_back( estimator( second, last ) );
+++ }
+++
+++ return results;
+++ }
+++
+++
+++ } // namespace
+++ } // namespace Detail
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++namespace Catch {
+++ namespace Benchmark {
+++ namespace Detail {
+++
+++ double weighted_average_quantile( int k,
+++ int q,
+++ double* first,
+++ double* last ) {
+++ auto count = last - first;
+++ double idx = (count - 1) * k / static_cast<double>(q);
+++ int j = static_cast<int>(idx);
+++ double g = idx - j;
+++ std::nth_element(first, first + j, last);
+++ auto xj = first[j];
+++ if ( Catch::Detail::directCompare( g, 0 ) ) {
+++ return xj;
+++ }
+++
+++ auto xj1 = *std::min_element(first + (j + 1), last);
+++ return xj + g * (xj1 - xj);
+++ }
+++
+++ OutlierClassification
+++ classify_outliers( double const* first, double const* last ) {
+++ std::vector<double> copy( first, last );
+++
+++ auto q1 = weighted_average_quantile( 1, 4, copy.data(), copy.data() + copy.size() );
+++ auto q3 = weighted_average_quantile( 3, 4, copy.data(), copy.data() + copy.size() );
+++ auto iqr = q3 - q1;
+++ auto los = q1 - ( iqr * 3. );
+++ auto lom = q1 - ( iqr * 1.5 );
+++ auto him = q3 + ( iqr * 1.5 );
+++ auto his = q3 + ( iqr * 3. );
+++
+++ OutlierClassification o;
+++ for ( ; first != last; ++first ) {
+++ const double t = *first;
+++ if ( t < los ) {
+++ ++o.low_severe;
+++ } else if ( t < lom ) {
+++ ++o.low_mild;
+++ } else if ( t > his ) {
+++ ++o.high_severe;
+++ } else if ( t > him ) {
+++ ++o.high_mild;
+++ }
+++ ++o.samples_seen;
+++ }
+++ return o;
+++ }
+++
+++ double mean( double const* first, double const* last ) {
+++ auto count = last - first;
+++ double sum = 0.;
+++ while (first != last) {
+++ sum += *first;
+++ ++first;
+++ }
+++ return sum / static_cast<double>(count);
+++ }
+++
+++ double normal_cdf( double x ) {
+++ return std::erfc( -x / std::sqrt( 2.0 ) ) / 2.0;
+++ }
+++
+++ double erfc_inv(double x) {
+++ return erf_inv(1.0 - x);
+++ }
+++
+++ double normal_quantile(double p) {
+++ static const double ROOT_TWO = std::sqrt(2.0);
+++
+++ double result = 0.0;
+++ assert(p >= 0 && p <= 1);
+++ if (p < 0 || p > 1) {
+++ return result;
+++ }
+++
+++ result = -erfc_inv(2.0 * p);
+++ // result *= normal distribution standard deviation (1.0) * sqrt(2)
+++ result *= /*sd * */ ROOT_TWO;
+++ // result += normal disttribution mean (0)
+++ return result;
+++ }
+++
+++ Estimate<double>
+++ bootstrap( double confidence_level,
+++ double* first,
+++ double* last,
+++ sample const& resample,
+++ double ( *estimator )( double const*, double const* ) ) {
+++ auto n_samples = last - first;
+++
+++ double point = estimator( first, last );
+++ // Degenerate case with a single sample
+++ if ( n_samples == 1 )
+++ return { point, point, point, confidence_level };
+++
+++ sample jack = jackknife( estimator, first, last );
+++ double jack_mean =
+++ mean( jack.data(), jack.data() + jack.size() );
+++ double sum_squares = 0, sum_cubes = 0;
+++ for ( double x : jack ) {
+++ auto difference = jack_mean - x;
+++ auto square = difference * difference;
+++ auto cube = square * difference;
+++ sum_squares += square;
+++ sum_cubes += cube;
+++ }
+++
+++ double accel = sum_cubes / ( 6 * std::pow( sum_squares, 1.5 ) );
+++ long n = static_cast<long>( resample.size() );
+++ double prob_n =
+++ std::count_if( resample.begin(),
+++ resample.end(),
+++ [point]( double x ) { return x < point; } ) /
+++ static_cast<double>( n );
+++ // degenerate case with uniform samples
+++ if ( Catch::Detail::directCompare( prob_n, 0. ) ) {
+++ return { point, point, point, confidence_level };
+++ }
+++
+++ double bias = normal_quantile( prob_n );
+++ double z1 = normal_quantile( ( 1. - confidence_level ) / 2. );
+++
+++ auto cumn = [n]( double x ) -> long {
+++ return std::lround( normal_cdf( x ) *
+++ static_cast<double>( n ) );
+++ };
+++ auto a = [bias, accel]( double b ) {
+++ return bias + b / ( 1. - accel * b );
+++ };
+++ double b1 = bias + z1;
+++ double b2 = bias - z1;
+++ double a1 = a( b1 );
+++ double a2 = a( b2 );
+++ auto lo = static_cast<size_t>( (std::max)( cumn( a1 ), 0l ) );
+++ auto hi =
+++ static_cast<size_t>( (std::min)( cumn( a2 ), n - 1 ) );
+++
+++ return { point, resample[lo], resample[hi], confidence_level };
+++ }
+++
+++ bootstrap_analysis analyse_samples(double confidence_level,
+++ unsigned int n_resamples,
+++ double* first,
+++ double* last) {
+++ auto mean = &Detail::mean;
+++ auto stddev = &standard_deviation;
+++
+++#if defined(CATCH_CONFIG_USE_ASYNC)
+++ auto Estimate = [=](double(*f)(double const*, double const*)) {
+++ std::random_device rd;
+++ auto seed = rd();
+++ return std::async(std::launch::async, [=] {
+++ SimplePcg32 rng( seed );
+++ auto resampled = resample(rng, n_resamples, first, last, f);
+++ return bootstrap(confidence_level, first, last, resampled, f);
+++ });
+++ };
+++
+++ auto mean_future = Estimate(mean);
+++ auto stddev_future = Estimate(stddev);
+++
+++ auto mean_estimate = mean_future.get();
+++ auto stddev_estimate = stddev_future.get();
+++#else
+++ auto Estimate = [=](double(*f)(double const* , double const*)) {
+++ std::random_device rd;
+++ auto seed = rd();
+++ SimplePcg32 rng( seed );
+++ auto resampled = resample(rng, n_resamples, first, last, f);
+++ return bootstrap(confidence_level, first, last, resampled, f);
+++ };
+++
+++ auto mean_estimate = Estimate(mean);
+++ auto stddev_estimate = Estimate(stddev);
+++#endif // CATCH_USE_ASYNC
+++
+++ auto n = static_cast<int>(last - first); // seriously, one can't use integral types without hell in C++
+++ double outlier_variance = Detail::outlier_variance(mean_estimate, stddev_estimate, n);
+++
+++ return { mean_estimate, stddev_estimate, outlier_variance };
+++ }
+++ } // namespace Detail
+++ } // namespace Benchmark
+++} // namespace Catch
+++
+++
+++
+++#include <cmath>
+++#include <limits>
+++
+++namespace {
+++
+++// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+++// But without the subtraction to allow for INFINITY in comparison
+++bool marginComparison(double lhs, double rhs, double margin) {
+++ return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+++}
+++
+++}
+++
+++namespace Catch {
+++
+++ Approx::Approx ( double value )
+++ : m_epsilon( static_cast<double>(std::numeric_limits<float>::epsilon())*100. ),
+++ m_margin( 0.0 ),
+++ m_scale( 0.0 ),
+++ m_value( value )
+++ {}
+++
+++ Approx Approx::custom() {
+++ return Approx( 0 );
+++ }
+++
+++ Approx Approx::operator-() const {
+++ auto temp(*this);
+++ temp.m_value = -temp.m_value;
+++ return temp;
+++ }
+++
+++
+++ std::string Approx::toString() const {
+++ ReusableStringStream rss;
+++ rss << "Approx( " << ::Catch::Detail::stringify( m_value ) << " )";
+++ return rss.str();
+++ }
+++
+++ bool Approx::equalityComparisonImpl(const double other) const {
+++ // First try with fixed margin, then compute margin based on epsilon, scale and Approx's value
+++ // Thanks to Richard Harris for his help refining the scaled margin value
+++ return marginComparison(m_value, other, m_margin)
+++ || marginComparison(m_value, other, m_epsilon * (m_scale + std::fabs(std::isinf(m_value)? 0 : m_value)));
+++ }
+++
+++ void Approx::setMargin(double newMargin) {
+++ CATCH_ENFORCE(newMargin >= 0,
+++ "Invalid Approx::margin: " << newMargin << '.'
+++ << " Approx::Margin has to be non-negative.");
+++ m_margin = newMargin;
+++ }
+++
+++ void Approx::setEpsilon(double newEpsilon) {
+++ CATCH_ENFORCE(newEpsilon >= 0 && newEpsilon <= 1.0,
+++ "Invalid Approx::epsilon: " << newEpsilon << '.'
+++ << " Approx::epsilon has to be in [0, 1]");
+++ m_epsilon = newEpsilon;
+++ }
+++
+++namespace literals {
+++ Approx operator ""_a(long double val) {
+++ return Approx(val);
+++ }
+++ Approx operator ""_a(unsigned long long val) {
+++ return Approx(val);
+++ }
+++} // end namespace literals
+++
+++std::string StringMaker<Catch::Approx>::convert(Catch::Approx const& value) {
+++ return value.toString();
+++}
+++
+++} // end namespace Catch
+++
+++
+++
+++namespace Catch {
+++
+++ AssertionResultData::AssertionResultData(ResultWas::OfType _resultType, LazyExpression const & _lazyExpression):
+++ lazyExpression(_lazyExpression),
+++ resultType(_resultType) {}
+++
+++ std::string AssertionResultData::reconstructExpression() const {
+++
+++ if( reconstructedExpression.empty() ) {
+++ if( lazyExpression ) {
+++ ReusableStringStream rss;
+++ rss << lazyExpression;
+++ reconstructedExpression = rss.str();
+++ }
+++ }
+++ return reconstructedExpression;
+++ }
+++
+++ AssertionResult::AssertionResult( AssertionInfo const& info, AssertionResultData&& data )
+++ : m_info( info ),
+++ m_resultData( CATCH_MOVE(data) )
+++ {}
+++
+++ // Result was a success
+++ bool AssertionResult::succeeded() const {
+++ return Catch::isOk( m_resultData.resultType );
+++ }
+++
+++ // Result was a success, or failure is suppressed
+++ bool AssertionResult::isOk() const {
+++ return Catch::isOk( m_resultData.resultType ) || shouldSuppressFailure( m_info.resultDisposition );
+++ }
+++
+++ ResultWas::OfType AssertionResult::getResultType() const {
+++ return m_resultData.resultType;
+++ }
+++
+++ bool AssertionResult::hasExpression() const {
+++ return !m_info.capturedExpression.empty();
+++ }
+++
+++ bool AssertionResult::hasMessage() const {
+++ return !m_resultData.message.empty();
+++ }
+++
+++ std::string AssertionResult::getExpression() const {
+++ // Possibly overallocating by 3 characters should be basically free
+++ std::string expr; expr.reserve(m_info.capturedExpression.size() + 3);
+++ if (isFalseTest(m_info.resultDisposition)) {
+++ expr += "!(";
+++ }
+++ expr += m_info.capturedExpression;
+++ if (isFalseTest(m_info.resultDisposition)) {
+++ expr += ')';
+++ }
+++ return expr;
+++ }
+++
+++ std::string AssertionResult::getExpressionInMacro() const {
+++ if ( m_info.macroName.empty() ) {
+++ return static_cast<std::string>( m_info.capturedExpression );
+++ }
+++ std::string expr;
+++ expr.reserve( m_info.macroName.size() + m_info.capturedExpression.size() + 4 );
+++ expr += m_info.macroName;
+++ expr += "( ";
+++ expr += m_info.capturedExpression;
+++ expr += " )";
+++ return expr;
+++ }
+++
+++ bool AssertionResult::hasExpandedExpression() const {
+++ return hasExpression() && getExpandedExpression() != getExpression();
+++ }
+++
+++ std::string AssertionResult::getExpandedExpression() const {
+++ std::string expr = m_resultData.reconstructExpression();
+++ return expr.empty()
+++ ? getExpression()
+++ : expr;
+++ }
+++
+++ StringRef AssertionResult::getMessage() const {
+++ return m_resultData.message;
+++ }
+++ SourceLineInfo AssertionResult::getSourceInfo() const {
+++ return m_info.lineInfo;
+++ }
+++
+++ StringRef AssertionResult::getTestMacroName() const {
+++ return m_info.macroName;
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++#include <fstream>
+++
+++namespace Catch {
+++
+++ namespace {
+++ static bool enableBazelEnvSupport() {
+++#if defined( CATCH_CONFIG_BAZEL_SUPPORT )
+++ return true;
+++#else
+++ return Detail::getEnv( "BAZEL_TEST" ) != nullptr;
+++#endif
+++ }
+++
+++ struct bazelShardingOptions {
+++ unsigned int shardIndex, shardCount;
+++ std::string shardFilePath;
+++ };
+++
+++ static Optional<bazelShardingOptions> readBazelShardingOptions() {
+++ const auto bazelShardIndex = Detail::getEnv( "TEST_SHARD_INDEX" );
+++ const auto bazelShardTotal = Detail::getEnv( "TEST_TOTAL_SHARDS" );
+++ const auto bazelShardInfoFile = Detail::getEnv( "TEST_SHARD_STATUS_FILE" );
+++
+++
+++ const bool has_all =
+++ bazelShardIndex && bazelShardTotal && bazelShardInfoFile;
+++ if ( !has_all ) {
+++ // We provide nice warning message if the input is
+++ // misconfigured.
+++ auto warn = []( const char* env_var ) {
+++ Catch::cerr()
+++ << "Warning: Bazel shard configuration is missing '"
+++ << env_var << "'. Shard configuration is skipped.\n";
+++ };
+++ if ( !bazelShardIndex ) {
+++ warn( "TEST_SHARD_INDEX" );
+++ }
+++ if ( !bazelShardTotal ) {
+++ warn( "TEST_TOTAL_SHARDS" );
+++ }
+++ if ( !bazelShardInfoFile ) {
+++ warn( "TEST_SHARD_STATUS_FILE" );
+++ }
+++ return {};
+++ }
+++
+++ auto shardIndex = parseUInt( bazelShardIndex );
+++ if ( !shardIndex ) {
+++ Catch::cerr()
+++ << "Warning: could not parse 'TEST_SHARD_INDEX' ('" << bazelShardIndex
+++ << "') as unsigned int.\n";
+++ return {};
+++ }
+++ auto shardTotal = parseUInt( bazelShardTotal );
+++ if ( !shardTotal ) {
+++ Catch::cerr()
+++ << "Warning: could not parse 'TEST_TOTAL_SHARD' ('"
+++ << bazelShardTotal << "') as unsigned int.\n";
+++ return {};
+++ }
+++
+++ return bazelShardingOptions{
+++ *shardIndex, *shardTotal, bazelShardInfoFile };
+++
+++ }
+++ } // end namespace
+++
+++
+++ bool operator==( ProcessedReporterSpec const& lhs,
+++ ProcessedReporterSpec const& rhs ) {
+++ return lhs.name == rhs.name &&
+++ lhs.outputFilename == rhs.outputFilename &&
+++ lhs.colourMode == rhs.colourMode &&
+++ lhs.customOptions == rhs.customOptions;
+++ }
+++
+++ Config::Config( ConfigData const& data ):
+++ m_data( data ) {
+++ // We need to trim filter specs to avoid trouble with superfluous
+++ // whitespace (esp. important for bdd macros, as those are manually
+++ // aligned with whitespace).
+++
+++ for (auto& elem : m_data.testsOrTags) {
+++ elem = trim(elem);
+++ }
+++ for (auto& elem : m_data.sectionsToRun) {
+++ elem = trim(elem);
+++ }
+++
+++ // Insert the default reporter if user hasn't asked for a specific one
+++ if ( m_data.reporterSpecifications.empty() ) {
+++#if defined( CATCH_CONFIG_DEFAULT_REPORTER )
+++ const auto default_spec = CATCH_CONFIG_DEFAULT_REPORTER;
+++#else
+++ const auto default_spec = "console";
+++#endif
+++ auto parsed = parseReporterSpec(default_spec);
+++ CATCH_ENFORCE( parsed,
+++ "Cannot parse the provided default reporter spec: '"
+++ << default_spec << '\'' );
+++ m_data.reporterSpecifications.push_back( std::move( *parsed ) );
+++ }
+++
+++ if ( enableBazelEnvSupport() ) {
+++ readBazelEnvVars();
+++ }
+++
+++ // Bazel support can modify the test specs, so parsing has to happen
+++ // after reading Bazel env vars.
+++ TestSpecParser parser( ITagAliasRegistry::get() );
+++ if ( !m_data.testsOrTags.empty() ) {
+++ m_hasTestFilters = true;
+++ for ( auto const& testOrTags : m_data.testsOrTags ) {
+++ parser.parse( testOrTags );
+++ }
+++ }
+++ m_testSpec = parser.testSpec();
+++
+++
+++ // We now fixup the reporter specs to handle default output spec,
+++ // default colour spec, etc
+++ bool defaultOutputUsed = false;
+++ for ( auto const& reporterSpec : m_data.reporterSpecifications ) {
+++ // We do the default-output check separately, while always
+++ // using the default output below to make the code simpler
+++ // and avoid superfluous copies.
+++ if ( reporterSpec.outputFile().none() ) {
+++ CATCH_ENFORCE( !defaultOutputUsed,
+++ "Internal error: cannot use default output for "
+++ "multiple reporters" );
+++ defaultOutputUsed = true;
+++ }
+++
+++ m_processedReporterSpecs.push_back( ProcessedReporterSpec{
+++ reporterSpec.name(),
+++ reporterSpec.outputFile() ? *reporterSpec.outputFile()
+++ : data.defaultOutputFilename,
+++ reporterSpec.colourMode().valueOr( data.defaultColourMode ),
+++ reporterSpec.customOptions() } );
+++ }
+++ }
+++
+++ Config::~Config() = default;
+++
+++
+++ bool Config::listTests() const { return m_data.listTests; }
+++ bool Config::listTags() const { return m_data.listTags; }
+++ bool Config::listReporters() const { return m_data.listReporters; }
+++ bool Config::listListeners() const { return m_data.listListeners; }
+++
+++ std::vector<std::string> const& Config::getTestsOrTags() const { return m_data.testsOrTags; }
+++ std::vector<std::string> const& Config::getSectionsToRun() const { return m_data.sectionsToRun; }
+++
+++ std::vector<ReporterSpec> const& Config::getReporterSpecs() const {
+++ return m_data.reporterSpecifications;
+++ }
+++
+++ std::vector<ProcessedReporterSpec> const&
+++ Config::getProcessedReporterSpecs() const {
+++ return m_processedReporterSpecs;
+++ }
+++
+++ TestSpec const& Config::testSpec() const { return m_testSpec; }
+++ bool Config::hasTestFilters() const { return m_hasTestFilters; }
+++
+++ bool Config::showHelp() const { return m_data.showHelp; }
+++
+++ // IConfig interface
+++ bool Config::allowThrows() const { return !m_data.noThrow; }
+++ StringRef Config::name() const { return m_data.name.empty() ? m_data.processName : m_data.name; }
+++ bool Config::includeSuccessfulResults() const { return m_data.showSuccessfulTests; }
+++ bool Config::warnAboutMissingAssertions() const {
+++ return !!( m_data.warnings & WarnAbout::NoAssertions );
+++ }
+++ bool Config::warnAboutUnmatchedTestSpecs() const {
+++ return !!( m_data.warnings & WarnAbout::UnmatchedTestSpec );
+++ }
+++ bool Config::zeroTestsCountAsSuccess() const { return m_data.allowZeroTests; }
+++ ShowDurations Config::showDurations() const { return m_data.showDurations; }
+++ double Config::minDuration() const { return m_data.minDuration; }
+++ TestRunOrder Config::runOrder() const { return m_data.runOrder; }
+++ uint32_t Config::rngSeed() const { return m_data.rngSeed; }
+++ unsigned int Config::shardCount() const { return m_data.shardCount; }
+++ unsigned int Config::shardIndex() const { return m_data.shardIndex; }
+++ ColourMode Config::defaultColourMode() const { return m_data.defaultColourMode; }
+++ bool Config::shouldDebugBreak() const { return m_data.shouldDebugBreak; }
+++ int Config::abortAfter() const { return m_data.abortAfter; }
+++ bool Config::showInvisibles() const { return m_data.showInvisibles; }
+++ Verbosity Config::verbosity() const { return m_data.verbosity; }
+++
+++ bool Config::skipBenchmarks() const { return m_data.skipBenchmarks; }
+++ bool Config::benchmarkNoAnalysis() const { return m_data.benchmarkNoAnalysis; }
+++ unsigned int Config::benchmarkSamples() const { return m_data.benchmarkSamples; }
+++ double Config::benchmarkConfidenceInterval() const { return m_data.benchmarkConfidenceInterval; }
+++ unsigned int Config::benchmarkResamples() const { return m_data.benchmarkResamples; }
+++ std::chrono::milliseconds Config::benchmarkWarmupTime() const { return std::chrono::milliseconds(m_data.benchmarkWarmupTime); }
+++
+++ void Config::readBazelEnvVars() {
+++ // Register a JUnit reporter for Bazel. Bazel sets an environment
+++ // variable with the path to XML output. If this file is written to
+++ // during test, Bazel will not generate a default XML output.
+++ // This allows the XML output file to contain higher level of detail
+++ // than what is possible otherwise.
+++ const auto bazelOutputFile = Detail::getEnv( "XML_OUTPUT_FILE" );
+++
+++ if ( bazelOutputFile ) {
+++ m_data.reporterSpecifications.push_back(
+++ { "junit", std::string( bazelOutputFile ), {}, {} } );
+++ }
+++
+++ const auto bazelTestSpec = Detail::getEnv( "TESTBRIDGE_TEST_ONLY" );
+++ if ( bazelTestSpec ) {
+++ // Presumably the test spec from environment should overwrite
+++ // the one we got from CLI (if we got any)
+++ m_data.testsOrTags.clear();
+++ m_data.testsOrTags.push_back( bazelTestSpec );
+++ }
+++
+++ const auto bazelShardOptions = readBazelShardingOptions();
+++ if ( bazelShardOptions ) {
+++ std::ofstream f( bazelShardOptions->shardFilePath,
+++ std::ios_base::out | std::ios_base::trunc );
+++ if ( f.is_open() ) {
+++ f << "";
+++ m_data.shardIndex = bazelShardOptions->shardIndex;
+++ m_data.shardCount = bazelShardOptions->shardCount;
+++ }
+++ }
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++
+++namespace Catch {
+++ std::uint32_t getSeed() {
+++ return getCurrentContext().getConfig()->rngSeed();
+++ }
+++}
+++
+++
+++
+++#include <cassert>
+++#include <stack>
+++
+++namespace Catch {
+++
+++ ////////////////////////////////////////////////////////////////////////////
+++
+++
+++ ScopedMessage::ScopedMessage( MessageBuilder&& builder ):
+++ m_info( CATCH_MOVE(builder.m_info) ) {
+++ m_info.message = builder.m_stream.str();
+++ getResultCapture().pushScopedMessage( m_info );
+++ }
+++
+++ ScopedMessage::ScopedMessage( ScopedMessage&& old ) noexcept:
+++ m_info( CATCH_MOVE( old.m_info ) ) {
+++ old.m_moved = true;
+++ }
+++
+++ ScopedMessage::~ScopedMessage() {
+++ if ( !uncaught_exceptions() && !m_moved ){
+++ getResultCapture().popScopedMessage(m_info);
+++ }
+++ }
+++
+++
+++ Capturer::Capturer( StringRef macroName,
+++ SourceLineInfo const& lineInfo,
+++ ResultWas::OfType resultType,
+++ StringRef names ):
+++ m_resultCapture( getResultCapture() ) {
+++ auto trimmed = [&] (size_t start, size_t end) {
+++ while (names[start] == ',' || isspace(static_cast<unsigned char>(names[start]))) {
+++ ++start;
+++ }
+++ while (names[end] == ',' || isspace(static_cast<unsigned char>(names[end]))) {
+++ --end;
+++ }
+++ return names.substr(start, end - start + 1);
+++ };
+++ auto skipq = [&] (size_t start, char quote) {
+++ for (auto i = start + 1; i < names.size() ; ++i) {
+++ if (names[i] == quote)
+++ return i;
+++ if (names[i] == '\\')
+++ ++i;
+++ }
+++ CATCH_INTERNAL_ERROR("CAPTURE parsing encountered unmatched quote");
+++ };
+++
+++ size_t start = 0;
+++ std::stack<char> openings;
+++ for (size_t pos = 0; pos < names.size(); ++pos) {
+++ char c = names[pos];
+++ switch (c) {
+++ case '[':
+++ case '{':
+++ case '(':
+++ // It is basically impossible to disambiguate between
+++ // comparison and start of template args in this context
+++// case '<':
+++ openings.push(c);
+++ break;
+++ case ']':
+++ case '}':
+++ case ')':
+++// case '>':
+++ openings.pop();
+++ break;
+++ case '"':
+++ case '\'':
+++ pos = skipq(pos, c);
+++ break;
+++ case ',':
+++ if (start != pos && openings.empty()) {
+++ m_messages.emplace_back(macroName, lineInfo, resultType);
+++ m_messages.back().message = static_cast<std::string>(trimmed(start, pos));
+++ m_messages.back().message += " := ";
+++ start = pos;
+++ }
+++ default:; // noop
+++ }
+++ }
+++ assert(openings.empty() && "Mismatched openings");
+++ m_messages.emplace_back(macroName, lineInfo, resultType);
+++ m_messages.back().message = static_cast<std::string>(trimmed(start, names.size() - 1));
+++ m_messages.back().message += " := ";
+++ }
+++ Capturer::~Capturer() {
+++ if ( !uncaught_exceptions() ){
+++ assert( m_captured == m_messages.size() );
+++ for( size_t i = 0; i < m_captured; ++i )
+++ m_resultCapture.popScopedMessage( m_messages[i] );
+++ }
+++ }
+++
+++ void Capturer::captureValue( size_t index, std::string const& value ) {
+++ assert( index < m_messages.size() );
+++ m_messages[index].message += value;
+++ m_resultCapture.pushScopedMessage( m_messages[index] );
+++ m_captured++;
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++#include <exception>
+++
+++namespace Catch {
+++
+++ namespace {
+++
+++ class RegistryHub : public IRegistryHub,
+++ public IMutableRegistryHub,
+++ private Detail::NonCopyable {
+++
+++ public: // IRegistryHub
+++ RegistryHub() = default;
+++ ReporterRegistry const& getReporterRegistry() const override {
+++ return m_reporterRegistry;
+++ }
+++ ITestCaseRegistry const& getTestCaseRegistry() const override {
+++ return m_testCaseRegistry;
+++ }
+++ IExceptionTranslatorRegistry const& getExceptionTranslatorRegistry() const override {
+++ return m_exceptionTranslatorRegistry;
+++ }
+++ ITagAliasRegistry const& getTagAliasRegistry() const override {
+++ return m_tagAliasRegistry;
+++ }
+++ StartupExceptionRegistry const& getStartupExceptionRegistry() const override {
+++ return m_exceptionRegistry;
+++ }
+++
+++ public: // IMutableRegistryHub
+++ void registerReporter( std::string const& name, IReporterFactoryPtr factory ) override {
+++ m_reporterRegistry.registerReporter( name, CATCH_MOVE(factory) );
+++ }
+++ void registerListener( Detail::unique_ptr<EventListenerFactory> factory ) override {
+++ m_reporterRegistry.registerListener( CATCH_MOVE(factory) );
+++ }
+++ void registerTest( Detail::unique_ptr<TestCaseInfo>&& testInfo, Detail::unique_ptr<ITestInvoker>&& invoker ) override {
+++ m_testCaseRegistry.registerTest( CATCH_MOVE(testInfo), CATCH_MOVE(invoker) );
+++ }
+++ void registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) override {
+++ m_exceptionTranslatorRegistry.registerTranslator( CATCH_MOVE(translator) );
+++ }
+++ void registerTagAlias( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) override {
+++ m_tagAliasRegistry.add( alias, tag, lineInfo );
+++ }
+++ void registerStartupException() noexcept override {
+++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+++ m_exceptionRegistry.add(std::current_exception());
+++#else
+++ CATCH_INTERNAL_ERROR("Attempted to register active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+++#endif
+++ }
+++ IMutableEnumValuesRegistry& getMutableEnumValuesRegistry() override {
+++ return m_enumValuesRegistry;
+++ }
+++
+++ private:
+++ TestRegistry m_testCaseRegistry;
+++ ReporterRegistry m_reporterRegistry;
+++ ExceptionTranslatorRegistry m_exceptionTranslatorRegistry;
+++ TagAliasRegistry m_tagAliasRegistry;
+++ StartupExceptionRegistry m_exceptionRegistry;
+++ Detail::EnumValuesRegistry m_enumValuesRegistry;
+++ };
+++ }
+++
+++ using RegistryHubSingleton = Singleton<RegistryHub, IRegistryHub, IMutableRegistryHub>;
+++
+++ IRegistryHub const& getRegistryHub() {
+++ return RegistryHubSingleton::get();
+++ }
+++ IMutableRegistryHub& getMutableRegistryHub() {
+++ return RegistryHubSingleton::getMutable();
+++ }
+++ void cleanUp() {
+++ cleanupSingletons();
+++ cleanUpContext();
+++ }
+++ std::string translateActiveException() {
+++ return getRegistryHub().getExceptionTranslatorRegistry().translateActiveException();
+++ }
+++
+++
+++} // end namespace Catch
+++
+++
+++
+++#include <algorithm>
+++#include <cassert>
+++#include <exception>
+++#include <iomanip>
+++#include <set>
+++
+++namespace Catch {
+++
+++ namespace {
+++ const int MaxExitCode = 255;
+++
+++ IEventListenerPtr createReporter(std::string const& reporterName, ReporterConfig&& config) {
+++ auto reporter = Catch::getRegistryHub().getReporterRegistry().create(reporterName, CATCH_MOVE(config));
+++ CATCH_ENFORCE(reporter, "No reporter registered with name: '" << reporterName << '\'');
+++
+++ return reporter;
+++ }
+++
+++ IEventListenerPtr prepareReporters(Config const* config) {
+++ if (Catch::getRegistryHub().getReporterRegistry().getListeners().empty()
+++ && config->getProcessedReporterSpecs().size() == 1) {
+++ auto const& spec = config->getProcessedReporterSpecs()[0];
+++ return createReporter(
+++ spec.name,
+++ ReporterConfig( config,
+++ makeStream( spec.outputFilename ),
+++ spec.colourMode,
+++ spec.customOptions ) );
+++ }
+++
+++ auto multi = Detail::make_unique<MultiReporter>(config);
+++
+++ auto const& listeners = Catch::getRegistryHub().getReporterRegistry().getListeners();
+++ for (auto const& listener : listeners) {
+++ multi->addListener(listener->create(config));
+++ }
+++
+++ for ( auto const& reporterSpec : config->getProcessedReporterSpecs() ) {
+++ multi->addReporter( createReporter(
+++ reporterSpec.name,
+++ ReporterConfig( config,
+++ makeStream( reporterSpec.outputFilename ),
+++ reporterSpec.colourMode,
+++ reporterSpec.customOptions ) ) );
+++ }
+++
+++ return multi;
+++ }
+++
+++ class TestGroup {
+++ public:
+++ explicit TestGroup(IEventListenerPtr&& reporter, Config const* config):
+++ m_reporter(reporter.get()),
+++ m_config{config},
+++ m_context{config, CATCH_MOVE(reporter)} {
+++
+++ assert( m_config->testSpec().getInvalidSpecs().empty() &&
+++ "Invalid test specs should be handled before running tests" );
+++
+++ auto const& allTestCases = getAllTestCasesSorted(*m_config);
+++ auto const& testSpec = m_config->testSpec();
+++ if ( !testSpec.hasFilters() ) {
+++ for ( auto const& test : allTestCases ) {
+++ if ( !test.getTestCaseInfo().isHidden() ) {
+++ m_tests.emplace( &test );
+++ }
+++ }
+++ } else {
+++ m_matches =
+++ testSpec.matchesByFilter( allTestCases, *m_config );
+++ for ( auto const& match : m_matches ) {
+++ m_tests.insert( match.tests.begin(),
+++ match.tests.end() );
+++ }
+++ }
+++
+++ m_tests = createShard(m_tests, m_config->shardCount(), m_config->shardIndex());
+++ }
+++
+++ Totals execute() {
+++ Totals totals;
+++ for (auto const& testCase : m_tests) {
+++ if (!m_context.aborting())
+++ totals += m_context.runTest(*testCase);
+++ else
+++ m_reporter->skipTest(testCase->getTestCaseInfo());
+++ }
+++
+++ for (auto const& match : m_matches) {
+++ if (match.tests.empty()) {
+++ m_unmatchedTestSpecs = true;
+++ m_reporter->noMatchingTestCases( match.name );
+++ }
+++ }
+++
+++ return totals;
+++ }
+++
+++ bool hadUnmatchedTestSpecs() const {
+++ return m_unmatchedTestSpecs;
+++ }
+++
+++
+++ private:
+++ IEventListener* m_reporter;
+++ Config const* m_config;
+++ RunContext m_context;
+++ std::set<TestCaseHandle const*> m_tests;
+++ TestSpec::Matches m_matches;
+++ bool m_unmatchedTestSpecs = false;
+++ };
+++
+++ void applyFilenamesAsTags() {
+++ for (auto const& testInfo : getRegistryHub().getTestCaseRegistry().getAllInfos()) {
+++ testInfo->addFilenameTag();
+++ }
+++ }
+++
+++ } // anon namespace
+++
+++ Session::Session() {
+++ static bool alreadyInstantiated = false;
+++ if( alreadyInstantiated ) {
+++ CATCH_TRY { CATCH_INTERNAL_ERROR( "Only one instance of Catch::Session can ever be used" ); }
+++ CATCH_CATCH_ALL { getMutableRegistryHub().registerStartupException(); }
+++ }
+++
+++ // There cannot be exceptions at startup in no-exception mode.
+++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+++ const auto& exceptions = getRegistryHub().getStartupExceptionRegistry().getExceptions();
+++ if ( !exceptions.empty() ) {
+++ config();
+++ getCurrentMutableContext().setConfig(m_config.get());
+++
+++ m_startupExceptions = true;
+++ auto errStream = makeStream( "%stderr" );
+++ auto colourImpl = makeColourImpl(
+++ ColourMode::PlatformDefault, errStream.get() );
+++ auto guard = colourImpl->guardColour( Colour::Red );
+++ errStream->stream() << "Errors occurred during startup!" << '\n';
+++ // iterate over all exceptions and notify user
+++ for ( const auto& ex_ptr : exceptions ) {
+++ try {
+++ std::rethrow_exception(ex_ptr);
+++ } catch ( std::exception const& ex ) {
+++ errStream->stream() << TextFlow::Column( ex.what() ).indent(2) << '\n';
+++ }
+++ }
+++ }
+++#endif
+++
+++ alreadyInstantiated = true;
+++ m_cli = makeCommandLineParser( m_configData );
+++ }
+++ Session::~Session() {
+++ Catch::cleanUp();
+++ }
+++
+++ void Session::showHelp() const {
+++ Catch::cout()
+++ << "\nCatch2 v" << libraryVersion() << '\n'
+++ << m_cli << '\n'
+++ << "For more detailed usage please see the project docs\n\n" << std::flush;
+++ }
+++ void Session::libIdentify() {
+++ Catch::cout()
+++ << std::left << std::setw(16) << "description: " << "A Catch2 test executable\n"
+++ << std::left << std::setw(16) << "category: " << "testframework\n"
+++ << std::left << std::setw(16) << "framework: " << "Catch2\n"
+++ << std::left << std::setw(16) << "version: " << libraryVersion() << '\n' << std::flush;
+++ }
+++
+++ int Session::applyCommandLine( int argc, char const * const * argv ) {
+++ if( m_startupExceptions )
+++ return 1;
+++
+++ auto result = m_cli.parse( Clara::Args( argc, argv ) );
+++
+++ if( !result ) {
+++ config();
+++ getCurrentMutableContext().setConfig(m_config.get());
+++ auto errStream = makeStream( "%stderr" );
+++ auto colour = makeColourImpl( ColourMode::PlatformDefault, errStream.get() );
+++
+++ errStream->stream()
+++ << colour->guardColour( Colour::Red )
+++ << "\nError(s) in input:\n"
+++ << TextFlow::Column( result.errorMessage() ).indent( 2 )
+++ << "\n\n";
+++ errStream->stream() << "Run with -? for usage\n\n" << std::flush;
+++ return MaxExitCode;
+++ }
+++
+++ if( m_configData.showHelp )
+++ showHelp();
+++ if( m_configData.libIdentify )
+++ libIdentify();
+++
+++ m_config.reset();
+++ return 0;
+++ }
+++
+++#if defined(CATCH_CONFIG_WCHAR) && defined(_WIN32) && defined(UNICODE)
+++ int Session::applyCommandLine( int argc, wchar_t const * const * argv ) {
+++
+++ char **utf8Argv = new char *[ argc ];
+++
+++ for ( int i = 0; i < argc; ++i ) {
+++ int bufSize = WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, nullptr, 0, nullptr, nullptr );
+++
+++ utf8Argv[ i ] = new char[ bufSize ];
+++
+++ WideCharToMultiByte( CP_UTF8, 0, argv[i], -1, utf8Argv[i], bufSize, nullptr, nullptr );
+++ }
+++
+++ int returnCode = applyCommandLine( argc, utf8Argv );
+++
+++ for ( int i = 0; i < argc; ++i )
+++ delete [] utf8Argv[ i ];
+++
+++ delete [] utf8Argv;
+++
+++ return returnCode;
+++ }
+++#endif
+++
+++ void Session::useConfigData( ConfigData const& configData ) {
+++ m_configData = configData;
+++ m_config.reset();
+++ }
+++
+++ int Session::run() {
+++ if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeStart ) != 0 ) {
+++ Catch::cout() << "...waiting for enter/ return before starting\n" << std::flush;
+++ static_cast<void>(std::getchar());
+++ }
+++ int exitCode = runInternal();
+++ if( ( m_configData.waitForKeypress & WaitForKeypress::BeforeExit ) != 0 ) {
+++ Catch::cout() << "...waiting for enter/ return before exiting, with code: " << exitCode << '\n' << std::flush;
+++ static_cast<void>(std::getchar());
+++ }
+++ return exitCode;
+++ }
+++
+++ Clara::Parser const& Session::cli() const {
+++ return m_cli;
+++ }
+++ void Session::cli( Clara::Parser const& newParser ) {
+++ m_cli = newParser;
+++ }
+++ ConfigData& Session::configData() {
+++ return m_configData;
+++ }
+++ Config& Session::config() {
+++ if( !m_config )
+++ m_config = Detail::make_unique<Config>( m_configData );
+++ return *m_config;
+++ }
+++
+++ int Session::runInternal() {
+++ if( m_startupExceptions )
+++ return 1;
+++
+++ if (m_configData.showHelp || m_configData.libIdentify) {
+++ return 0;
+++ }
+++
+++ if ( m_configData.shardIndex >= m_configData.shardCount ) {
+++ Catch::cerr() << "The shard count (" << m_configData.shardCount
+++ << ") must be greater than the shard index ("
+++ << m_configData.shardIndex << ")\n"
+++ << std::flush;
+++ return 1;
+++ }
+++
+++ CATCH_TRY {
+++ config(); // Force config to be constructed
+++
+++ seedRng( *m_config );
+++
+++ if (m_configData.filenamesAsTags) {
+++ applyFilenamesAsTags();
+++ }
+++
+++ // Set up global config instance before we start calling into other functions
+++ getCurrentMutableContext().setConfig(m_config.get());
+++
+++ // Create reporter(s) so we can route listings through them
+++ auto reporter = prepareReporters(m_config.get());
+++
+++ auto const& invalidSpecs = m_config->testSpec().getInvalidSpecs();
+++ if ( !invalidSpecs.empty() ) {
+++ for ( auto const& spec : invalidSpecs ) {
+++ reporter->reportInvalidTestSpec( spec );
+++ }
+++ return 1;
+++ }
+++
+++
+++ // Handle list request
+++ if (list(*reporter, *m_config)) {
+++ return 0;
+++ }
+++
+++ TestGroup tests { CATCH_MOVE(reporter), m_config.get() };
+++ auto const totals = tests.execute();
+++
+++ if ( tests.hadUnmatchedTestSpecs()
+++ && m_config->warnAboutUnmatchedTestSpecs() ) {
+++ return 3;
+++ }
+++
+++ if ( totals.testCases.total() == 0
+++ && !m_config->zeroTestsCountAsSuccess() ) {
+++ return 2;
+++ }
+++
+++ if ( totals.testCases.total() > 0 &&
+++ totals.testCases.total() == totals.testCases.skipped
+++ && !m_config->zeroTestsCountAsSuccess() ) {
+++ return 4;
+++ }
+++
+++ // Note that on unices only the lower 8 bits are usually used, clamping
+++ // the return value to 255 prevents false negative when some multiple
+++ // of 256 tests has failed
+++ return (std::min) (MaxExitCode, static_cast<int>(totals.assertions.failed));
+++ }
+++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+++ catch( std::exception& ex ) {
+++ Catch::cerr() << ex.what() << '\n' << std::flush;
+++ return MaxExitCode;
+++ }
+++#endif
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++namespace Catch {
+++
+++ RegistrarForTagAliases::RegistrarForTagAliases(char const* alias, char const* tag, SourceLineInfo const& lineInfo) {
+++ CATCH_TRY {
+++ getMutableRegistryHub().registerTagAlias(alias, tag, lineInfo);
+++ } CATCH_CATCH_ALL {
+++ // Do not throw when constructing global objects, instead register the exception to be processed later
+++ getMutableRegistryHub().registerStartupException();
+++ }
+++ }
+++
+++}
+++
+++
+++
+++#include <cassert>
+++#include <cctype>
+++#include <algorithm>
+++
+++namespace Catch {
+++
+++ namespace {
+++ using TCP_underlying_type = uint8_t;
+++ static_assert(sizeof(TestCaseProperties) == sizeof(TCP_underlying_type),
+++ "The size of the TestCaseProperties is different from the assumed size");
+++
+++ TestCaseProperties operator|(TestCaseProperties lhs, TestCaseProperties rhs) {
+++ return static_cast<TestCaseProperties>(
+++ static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
+++ );
+++ }
+++
+++ TestCaseProperties& operator|=(TestCaseProperties& lhs, TestCaseProperties rhs) {
+++ lhs = static_cast<TestCaseProperties>(
+++ static_cast<TCP_underlying_type>(lhs) | static_cast<TCP_underlying_type>(rhs)
+++ );
+++ return lhs;
+++ }
+++
+++ TestCaseProperties operator&(TestCaseProperties lhs, TestCaseProperties rhs) {
+++ return static_cast<TestCaseProperties>(
+++ static_cast<TCP_underlying_type>(lhs) & static_cast<TCP_underlying_type>(rhs)
+++ );
+++ }
+++
+++ bool applies(TestCaseProperties tcp) {
+++ static_assert(static_cast<TCP_underlying_type>(TestCaseProperties::None) == 0,
+++ "TestCaseProperties::None must be equal to 0");
+++ return tcp != TestCaseProperties::None;
+++ }
+++
+++ TestCaseProperties parseSpecialTag( StringRef tag ) {
+++ if( !tag.empty() && tag[0] == '.' )
+++ return TestCaseProperties::IsHidden;
+++ else if( tag == "!throws"_sr )
+++ return TestCaseProperties::Throws;
+++ else if( tag == "!shouldfail"_sr )
+++ return TestCaseProperties::ShouldFail;
+++ else if( tag == "!mayfail"_sr )
+++ return TestCaseProperties::MayFail;
+++ else if( tag == "!nonportable"_sr )
+++ return TestCaseProperties::NonPortable;
+++ else if( tag == "!benchmark"_sr )
+++ return TestCaseProperties::Benchmark | TestCaseProperties::IsHidden;
+++ else
+++ return TestCaseProperties::None;
+++ }
+++ bool isReservedTag( StringRef tag ) {
+++ return parseSpecialTag( tag ) == TestCaseProperties::None
+++ && tag.size() > 0
+++ && !std::isalnum( static_cast<unsigned char>(tag[0]) );
+++ }
+++ void enforceNotReservedTag( StringRef tag, SourceLineInfo const& _lineInfo ) {
+++ CATCH_ENFORCE( !isReservedTag(tag),
+++ "Tag name: [" << tag << "] is not allowed.\n"
+++ << "Tag names starting with non alphanumeric characters are reserved\n"
+++ << _lineInfo );
+++ }
+++
+++ std::string makeDefaultName() {
+++ static size_t counter = 0;
+++ return "Anonymous test case " + std::to_string(++counter);
+++ }
+++
+++ StringRef extractFilenamePart(StringRef filename) {
+++ size_t lastDot = filename.size();
+++ while (lastDot > 0 && filename[lastDot - 1] != '.') {
+++ --lastDot;
+++ }
+++ // In theory we could have filename without any extension in it
+++ if ( lastDot == 0 ) { return StringRef(); }
+++
+++ --lastDot;
+++ size_t nameStart = lastDot;
+++ while (nameStart > 0 && filename[nameStart - 1] != '/' && filename[nameStart - 1] != '\\') {
+++ --nameStart;
+++ }
+++
+++ return filename.substr(nameStart, lastDot - nameStart);
+++ }
+++
+++ // Returns the upper bound on size of extra tags ([#file]+[.])
+++ size_t sizeOfExtraTags(StringRef filepath) {
+++ // [.] is 3, [#] is another 3
+++ const size_t extras = 3 + 3;
+++ return extractFilenamePart(filepath).size() + extras;
+++ }
+++ } // end unnamed namespace
+++
+++ bool operator<( Tag const& lhs, Tag const& rhs ) {
+++ Detail::CaseInsensitiveLess cmp;
+++ return cmp( lhs.original, rhs.original );
+++ }
+++ bool operator==( Tag const& lhs, Tag const& rhs ) {
+++ Detail::CaseInsensitiveEqualTo cmp;
+++ return cmp( lhs.original, rhs.original );
+++ }
+++
+++ Detail::unique_ptr<TestCaseInfo>
+++ makeTestCaseInfo(StringRef _className,
+++ NameAndTags const& nameAndTags,
+++ SourceLineInfo const& _lineInfo ) {
+++ return Detail::make_unique<TestCaseInfo>(_className, nameAndTags, _lineInfo);
+++ }
+++
+++ TestCaseInfo::TestCaseInfo(StringRef _className,
+++ NameAndTags const& _nameAndTags,
+++ SourceLineInfo const& _lineInfo):
+++ name( _nameAndTags.name.empty() ? makeDefaultName() : _nameAndTags.name ),
+++ className( _className ),
+++ lineInfo( _lineInfo )
+++ {
+++ StringRef originalTags = _nameAndTags.tags;
+++ // We need to reserve enough space to store all of the tags
+++ // (including optional hidden tag and filename tag)
+++ auto requiredSize = originalTags.size() + sizeOfExtraTags(_lineInfo.file);
+++ backingTags.reserve(requiredSize);
+++
+++ // We cannot copy the tags directly, as we need to normalize
+++ // some tags, so that [.foo] is copied as [.][foo].
+++ size_t tagStart = 0;
+++ size_t tagEnd = 0;
+++ bool inTag = false;
+++ for (size_t idx = 0; idx < originalTags.size(); ++idx) {
+++ auto c = originalTags[idx];
+++ if (c == '[') {
+++ CATCH_ENFORCE(
+++ !inTag,
+++ "Found '[' inside a tag while registering test case '"
+++ << _nameAndTags.name << "' at " << _lineInfo );
+++
+++ inTag = true;
+++ tagStart = idx;
+++ }
+++ if (c == ']') {
+++ CATCH_ENFORCE(
+++ inTag,
+++ "Found unmatched ']' while registering test case '"
+++ << _nameAndTags.name << "' at " << _lineInfo );
+++
+++ inTag = false;
+++ tagEnd = idx;
+++ assert(tagStart < tagEnd);
+++
+++ // We need to check the tag for special meanings, copy
+++ // it over to backing storage and actually reference the
+++ // backing storage in the saved tags
+++ StringRef tagStr = originalTags.substr(tagStart+1, tagEnd - tagStart - 1);
+++ CATCH_ENFORCE( !tagStr.empty(),
+++ "Found an empty tag while registering test case '"
+++ << _nameAndTags.name << "' at "
+++ << _lineInfo );
+++
+++ enforceNotReservedTag(tagStr, lineInfo);
+++ properties |= parseSpecialTag(tagStr);
+++ // When copying a tag to the backing storage, we need to
+++ // check if it is a merged hide tag, such as [.foo], and
+++ // if it is, we need to handle it as if it was [foo].
+++ if (tagStr.size() > 1 && tagStr[0] == '.') {
+++ tagStr = tagStr.substr(1, tagStr.size() - 1);
+++ }
+++ // We skip over dealing with the [.] tag, as we will add
+++ // it later unconditionally and then sort and unique all
+++ // the tags.
+++ internalAppendTag(tagStr);
+++ }
+++ }
+++ CATCH_ENFORCE( !inTag,
+++ "Found an unclosed tag while registering test case '"
+++ << _nameAndTags.name << "' at " << _lineInfo );
+++
+++
+++ // Add [.] if relevant
+++ if (isHidden()) {
+++ internalAppendTag("."_sr);
+++ }
+++
+++ // Sort and prepare tags
+++ std::sort(begin(tags), end(tags));
+++ tags.erase(std::unique(begin(tags), end(tags)),
+++ end(tags));
+++ }
+++
+++ bool TestCaseInfo::isHidden() const {
+++ return applies( properties & TestCaseProperties::IsHidden );
+++ }
+++ bool TestCaseInfo::throws() const {
+++ return applies( properties & TestCaseProperties::Throws );
+++ }
+++ bool TestCaseInfo::okToFail() const {
+++ return applies( properties & (TestCaseProperties::ShouldFail | TestCaseProperties::MayFail ) );
+++ }
+++ bool TestCaseInfo::expectedToFail() const {
+++ return applies( properties & (TestCaseProperties::ShouldFail) );
+++ }
+++
+++ void TestCaseInfo::addFilenameTag() {
+++ std::string combined("#");
+++ combined += extractFilenamePart(lineInfo.file);
+++ internalAppendTag(combined);
+++ }
+++
+++ std::string TestCaseInfo::tagsAsString() const {
+++ std::string ret;
+++ // '[' and ']' per tag
+++ std::size_t full_size = 2 * tags.size();
+++ for (const auto& tag : tags) {
+++ full_size += tag.original.size();
+++ }
+++ ret.reserve(full_size);
+++ for (const auto& tag : tags) {
+++ ret.push_back('[');
+++ ret += tag.original;
+++ ret.push_back(']');
+++ }
+++
+++ return ret;
+++ }
+++
+++ void TestCaseInfo::internalAppendTag(StringRef tagStr) {
+++ backingTags += '[';
+++ const auto backingStart = backingTags.size();
+++ backingTags += tagStr;
+++ const auto backingEnd = backingTags.size();
+++ backingTags += ']';
+++ tags.emplace_back(StringRef(backingTags.c_str() + backingStart, backingEnd - backingStart));
+++ }
+++
+++ bool operator<( TestCaseInfo const& lhs, TestCaseInfo const& rhs ) {
+++ // We want to avoid redoing the string comparisons multiple times,
+++ // so we store the result of a three-way comparison before using
+++ // it in the actual comparison logic.
+++ const auto cmpName = lhs.name.compare( rhs.name );
+++ if ( cmpName != 0 ) {
+++ return cmpName < 0;
+++ }
+++ const auto cmpClassName = lhs.className.compare( rhs.className );
+++ if ( cmpClassName != 0 ) {
+++ return cmpClassName < 0;
+++ }
+++ return lhs.tags < rhs.tags;
+++ }
+++
+++ TestCaseInfo const& TestCaseHandle::getTestCaseInfo() const {
+++ return *m_info;
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++#include <algorithm>
+++#include <string>
+++#include <vector>
+++#include <ostream>
+++
+++namespace Catch {
+++
+++ TestSpec::Pattern::Pattern( std::string const& name )
+++ : m_name( name )
+++ {}
+++
+++ TestSpec::Pattern::~Pattern() = default;
+++
+++ std::string const& TestSpec::Pattern::name() const {
+++ return m_name;
+++ }
+++
+++
+++ TestSpec::NamePattern::NamePattern( std::string const& name, std::string const& filterString )
+++ : Pattern( filterString )
+++ , m_wildcardPattern( toLower( name ), CaseSensitive::No )
+++ {}
+++
+++ bool TestSpec::NamePattern::matches( TestCaseInfo const& testCase ) const {
+++ return m_wildcardPattern.matches( testCase.name );
+++ }
+++
+++ void TestSpec::NamePattern::serializeTo( std::ostream& out ) const {
+++ out << '"' << name() << '"';
+++ }
+++
+++
+++ TestSpec::TagPattern::TagPattern( std::string const& tag, std::string const& filterString )
+++ : Pattern( filterString )
+++ , m_tag( tag )
+++ {}
+++
+++ bool TestSpec::TagPattern::matches( TestCaseInfo const& testCase ) const {
+++ return std::find( begin( testCase.tags ),
+++ end( testCase.tags ),
+++ Tag( m_tag ) ) != end( testCase.tags );
+++ }
+++
+++ void TestSpec::TagPattern::serializeTo( std::ostream& out ) const {
+++ out << name();
+++ }
+++
+++ bool TestSpec::Filter::matches( TestCaseInfo const& testCase ) const {
+++ bool should_use = !testCase.isHidden();
+++ for (auto const& pattern : m_required) {
+++ should_use = true;
+++ if (!pattern->matches(testCase)) {
+++ return false;
+++ }
+++ }
+++ for (auto const& pattern : m_forbidden) {
+++ if (pattern->matches(testCase)) {
+++ return false;
+++ }
+++ }
+++ return should_use;
+++ }
+++
+++ void TestSpec::Filter::serializeTo( std::ostream& out ) const {
+++ bool first = true;
+++ for ( auto const& pattern : m_required ) {
+++ if ( !first ) {
+++ out << ' ';
+++ }
+++ out << *pattern;
+++ first = false;
+++ }
+++ for ( auto const& pattern : m_forbidden ) {
+++ if ( !first ) {
+++ out << ' ';
+++ }
+++ out << *pattern;
+++ first = false;
+++ }
+++ }
+++
+++
+++ std::string TestSpec::extractFilterName( Filter const& filter ) {
+++ Catch::ReusableStringStream sstr;
+++ sstr << filter;
+++ return sstr.str();
+++ }
+++
+++ bool TestSpec::hasFilters() const {
+++ return !m_filters.empty();
+++ }
+++
+++ bool TestSpec::matches( TestCaseInfo const& testCase ) const {
+++ return std::any_of( m_filters.begin(), m_filters.end(), [&]( Filter const& f ){ return f.matches( testCase ); } );
+++ }
+++
+++ TestSpec::Matches TestSpec::matchesByFilter( std::vector<TestCaseHandle> const& testCases, IConfig const& config ) const {
+++ Matches matches;
+++ matches.reserve( m_filters.size() );
+++ for ( auto const& filter : m_filters ) {
+++ std::vector<TestCaseHandle const*> currentMatches;
+++ for ( auto const& test : testCases )
+++ if ( isThrowSafe( test, config ) &&
+++ filter.matches( test.getTestCaseInfo() ) )
+++ currentMatches.emplace_back( &test );
+++ matches.push_back(
+++ FilterMatch{ extractFilterName( filter ), currentMatches } );
+++ }
+++ return matches;
+++ }
+++
+++ const TestSpec::vectorStrings& TestSpec::getInvalidSpecs() const {
+++ return m_invalidSpecs;
+++ }
+++
+++ void TestSpec::serializeTo( std::ostream& out ) const {
+++ bool first = true;
+++ for ( auto const& filter : m_filters ) {
+++ if ( !first ) {
+++ out << ',';
+++ }
+++ out << filter;
+++ first = false;
+++ }
+++ }
+++
+++}
+++
+++
+++
+++#include <chrono>
+++
+++namespace Catch {
+++
+++ namespace {
+++ static auto getCurrentNanosecondsSinceEpoch() -> uint64_t {
+++ return std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count();
+++ }
+++ } // end unnamed namespace
+++
+++ void Timer::start() {
+++ m_nanoseconds = getCurrentNanosecondsSinceEpoch();
+++ }
+++ auto Timer::getElapsedNanoseconds() const -> uint64_t {
+++ return getCurrentNanosecondsSinceEpoch() - m_nanoseconds;
+++ }
+++ auto Timer::getElapsedMicroseconds() const -> uint64_t {
+++ return getElapsedNanoseconds()/1000;
+++ }
+++ auto Timer::getElapsedMilliseconds() const -> unsigned int {
+++ return static_cast<unsigned int>(getElapsedMicroseconds()/1000);
+++ }
+++ auto Timer::getElapsedSeconds() const -> double {
+++ return getElapsedMicroseconds()/1000000.0;
+++ }
+++
+++
+++} // namespace Catch
+++
+++
+++
+++
+++#include <cmath>
+++#include <iomanip>
+++
+++namespace Catch {
+++
+++namespace Detail {
+++
+++ namespace {
+++ const int hexThreshold = 255;
+++
+++ struct Endianness {
+++ enum Arch { Big, Little };
+++
+++ static Arch which() {
+++ int one = 1;
+++ // If the lowest byte we read is non-zero, we can assume
+++ // that little endian format is used.
+++ auto value = *reinterpret_cast<char*>(&one);
+++ return value ? Little : Big;
+++ }
+++ };
+++
+++ template<typename T>
+++ std::string fpToString(T value, int precision) {
+++ if (Catch::isnan(value)) {
+++ return "nan";
+++ }
+++
+++ ReusableStringStream rss;
+++ rss << std::setprecision(precision)
+++ << std::fixed
+++ << value;
+++ std::string d = rss.str();
+++ std::size_t i = d.find_last_not_of('0');
+++ if (i != std::string::npos && i != d.size() - 1) {
+++ if (d[i] == '.')
+++ i++;
+++ d = d.substr(0, i + 1);
+++ }
+++ return d;
+++ }
+++ } // end unnamed namespace
+++
+++ std::string convertIntoString(StringRef string, bool escapeInvisibles) {
+++ std::string ret;
+++ // This is enough for the "don't escape invisibles" case, and a good
+++ // lower bound on the "escape invisibles" case.
+++ ret.reserve(string.size() + 2);
+++
+++ if (!escapeInvisibles) {
+++ ret += '"';
+++ ret += string;
+++ ret += '"';
+++ return ret;
+++ }
+++
+++ ret += '"';
+++ for (char c : string) {
+++ switch (c) {
+++ case '\r':
+++ ret.append("\\r");
+++ break;
+++ case '\n':
+++ ret.append("\\n");
+++ break;
+++ case '\t':
+++ ret.append("\\t");
+++ break;
+++ case '\f':
+++ ret.append("\\f");
+++ break;
+++ default:
+++ ret.push_back(c);
+++ break;
+++ }
+++ }
+++ ret += '"';
+++
+++ return ret;
+++ }
+++
+++ std::string convertIntoString(StringRef string) {
+++ return convertIntoString(string, getCurrentContext().getConfig()->showInvisibles());
+++ }
+++
+++ std::string rawMemoryToString( const void *object, std::size_t size ) {
+++ // Reverse order for little endian architectures
+++ int i = 0, end = static_cast<int>( size ), inc = 1;
+++ if( Endianness::which() == Endianness::Little ) {
+++ i = end-1;
+++ end = inc = -1;
+++ }
+++
+++ unsigned char const *bytes = static_cast<unsigned char const *>(object);
+++ ReusableStringStream rss;
+++ rss << "0x" << std::setfill('0') << std::hex;
+++ for( ; i != end; i += inc )
+++ rss << std::setw(2) << static_cast<unsigned>(bytes[i]);
+++ return rss.str();
+++ }
+++} // end Detail namespace
+++
+++
+++
+++//// ======================================================= ////
+++//
+++// Out-of-line defs for full specialization of StringMaker
+++//
+++//// ======================================================= ////
+++
+++std::string StringMaker<std::string>::convert(const std::string& str) {
+++ return Detail::convertIntoString( str );
+++}
+++
+++#ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+++std::string StringMaker<std::string_view>::convert(std::string_view str) {
+++ return Detail::convertIntoString( StringRef( str.data(), str.size() ) );
+++}
+++#endif
+++
+++std::string StringMaker<char const*>::convert(char const* str) {
+++ if (str) {
+++ return Detail::convertIntoString( str );
+++ } else {
+++ return{ "{null string}" };
+++ }
+++}
+++std::string StringMaker<char*>::convert(char* str) { // NOLINT(readability-non-const-parameter)
+++ if (str) {
+++ return Detail::convertIntoString( str );
+++ } else {
+++ return{ "{null string}" };
+++ }
+++}
+++
+++#ifdef CATCH_CONFIG_WCHAR
+++std::string StringMaker<std::wstring>::convert(const std::wstring& wstr) {
+++ std::string s;
+++ s.reserve(wstr.size());
+++ for (auto c : wstr) {
+++ s += (c <= 0xff) ? static_cast<char>(c) : '?';
+++ }
+++ return ::Catch::Detail::stringify(s);
+++}
+++
+++# ifdef CATCH_CONFIG_CPP17_STRING_VIEW
+++std::string StringMaker<std::wstring_view>::convert(std::wstring_view str) {
+++ return StringMaker<std::wstring>::convert(std::wstring(str));
+++}
+++# endif
+++
+++std::string StringMaker<wchar_t const*>::convert(wchar_t const * str) {
+++ if (str) {
+++ return ::Catch::Detail::stringify(std::wstring{ str });
+++ } else {
+++ return{ "{null string}" };
+++ }
+++}
+++std::string StringMaker<wchar_t *>::convert(wchar_t * str) {
+++ if (str) {
+++ return ::Catch::Detail::stringify(std::wstring{ str });
+++ } else {
+++ return{ "{null string}" };
+++ }
+++}
+++#endif
+++
+++#if defined(CATCH_CONFIG_CPP17_BYTE)
+++#include <cstddef>
+++std::string StringMaker<std::byte>::convert(std::byte value) {
+++ return ::Catch::Detail::stringify(std::to_integer<unsigned long long>(value));
+++}
+++#endif // defined(CATCH_CONFIG_CPP17_BYTE)
+++
+++std::string StringMaker<int>::convert(int value) {
+++ return ::Catch::Detail::stringify(static_cast<long long>(value));
+++}
+++std::string StringMaker<long>::convert(long value) {
+++ return ::Catch::Detail::stringify(static_cast<long long>(value));
+++}
+++std::string StringMaker<long long>::convert(long long value) {
+++ ReusableStringStream rss;
+++ rss << value;
+++ if (value > Detail::hexThreshold) {
+++ rss << " (0x" << std::hex << value << ')';
+++ }
+++ return rss.str();
+++}
+++
+++std::string StringMaker<unsigned int>::convert(unsigned int value) {
+++ return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+++}
+++std::string StringMaker<unsigned long>::convert(unsigned long value) {
+++ return ::Catch::Detail::stringify(static_cast<unsigned long long>(value));
+++}
+++std::string StringMaker<unsigned long long>::convert(unsigned long long value) {
+++ ReusableStringStream rss;
+++ rss << value;
+++ if (value > Detail::hexThreshold) {
+++ rss << " (0x" << std::hex << value << ')';
+++ }
+++ return rss.str();
+++}
+++
+++std::string StringMaker<signed char>::convert(signed char value) {
+++ if (value == '\r') {
+++ return "'\\r'";
+++ } else if (value == '\f') {
+++ return "'\\f'";
+++ } else if (value == '\n') {
+++ return "'\\n'";
+++ } else if (value == '\t') {
+++ return "'\\t'";
+++ } else if ('\0' <= value && value < ' ') {
+++ return ::Catch::Detail::stringify(static_cast<unsigned int>(value));
+++ } else {
+++ char chstr[] = "' '";
+++ chstr[1] = value;
+++ return chstr;
+++ }
+++}
+++std::string StringMaker<char>::convert(char c) {
+++ return ::Catch::Detail::stringify(static_cast<signed char>(c));
+++}
+++std::string StringMaker<unsigned char>::convert(unsigned char value) {
+++ return ::Catch::Detail::stringify(static_cast<char>(value));
+++}
+++
+++int StringMaker<float>::precision = std::numeric_limits<float>::max_digits10;
+++
+++std::string StringMaker<float>::convert(float value) {
+++ return Detail::fpToString(value, precision) + 'f';
+++}
+++
+++int StringMaker<double>::precision = std::numeric_limits<double>::max_digits10;
+++
+++std::string StringMaker<double>::convert(double value) {
+++ return Detail::fpToString(value, precision);
+++}
+++
+++} // end namespace Catch
+++
+++
+++
+++namespace Catch {
+++
+++ Counts Counts::operator - ( Counts const& other ) const {
+++ Counts diff;
+++ diff.passed = passed - other.passed;
+++ diff.failed = failed - other.failed;
+++ diff.failedButOk = failedButOk - other.failedButOk;
+++ diff.skipped = skipped - other.skipped;
+++ return diff;
+++ }
+++
+++ Counts& Counts::operator += ( Counts const& other ) {
+++ passed += other.passed;
+++ failed += other.failed;
+++ failedButOk += other.failedButOk;
+++ skipped += other.skipped;
+++ return *this;
+++ }
+++
+++ std::uint64_t Counts::total() const {
+++ return passed + failed + failedButOk + skipped;
+++ }
+++ bool Counts::allPassed() const {
+++ return failed == 0 && failedButOk == 0 && skipped == 0;
+++ }
+++ bool Counts::allOk() const {
+++ return failed == 0;
+++ }
+++
+++ Totals Totals::operator - ( Totals const& other ) const {
+++ Totals diff;
+++ diff.assertions = assertions - other.assertions;
+++ diff.testCases = testCases - other.testCases;
+++ return diff;
+++ }
+++
+++ Totals& Totals::operator += ( Totals const& other ) {
+++ assertions += other.assertions;
+++ testCases += other.testCases;
+++ return *this;
+++ }
+++
+++ Totals Totals::delta( Totals const& prevTotals ) const {
+++ Totals diff = *this - prevTotals;
+++ if( diff.assertions.failed > 0 )
+++ ++diff.testCases.failed;
+++ else if( diff.assertions.failedButOk > 0 )
+++ ++diff.testCases.failedButOk;
+++ else if ( diff.assertions.skipped > 0 )
+++ ++ diff.testCases.skipped;
+++ else
+++ ++diff.testCases.passed;
+++ return diff;
+++ }
+++
+++}
+++
+++
+++
+++
+++namespace Catch {
+++ namespace Detail {
+++ void registerTranslatorImpl(
+++ Detail::unique_ptr<IExceptionTranslator>&& translator ) {
+++ getMutableRegistryHub().registerTranslator(
+++ CATCH_MOVE( translator ) );
+++ }
+++ } // namespace Detail
+++} // namespace Catch
+++
+++
+++#include <ostream>
+++
+++namespace Catch {
+++
+++ Version::Version
+++ ( unsigned int _majorVersion,
+++ unsigned int _minorVersion,
+++ unsigned int _patchNumber,
+++ char const * const _branchName,
+++ unsigned int _buildNumber )
+++ : majorVersion( _majorVersion ),
+++ minorVersion( _minorVersion ),
+++ patchNumber( _patchNumber ),
+++ branchName( _branchName ),
+++ buildNumber( _buildNumber )
+++ {}
+++
+++ std::ostream& operator << ( std::ostream& os, Version const& version ) {
+++ os << version.majorVersion << '.'
+++ << version.minorVersion << '.'
+++ << version.patchNumber;
+++ // branchName is never null -> 0th char is \0 if it is empty
+++ if (version.branchName[0]) {
+++ os << '-' << version.branchName
+++ << '.' << version.buildNumber;
+++ }
+++ return os;
+++ }
+++
+++ Version const& libraryVersion() {
+++ static Version version( 3, 6, 0, "", 0 );
+++ return version;
+++ }
+++
+++}
+++
+++
+++
+++
+++namespace Catch {
+++
+++ const char* GeneratorException::what() const noexcept {
+++ return m_msg;
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++namespace Catch {
+++
+++ IGeneratorTracker::~IGeneratorTracker() = default;
+++
+++namespace Generators {
+++
+++namespace Detail {
+++
+++ [[noreturn]]
+++ void throw_generator_exception(char const* msg) {
+++ Catch::throw_exception(GeneratorException{ msg });
+++ }
+++} // end namespace Detail
+++
+++ GeneratorUntypedBase::~GeneratorUntypedBase() = default;
+++
+++ IGeneratorTracker* acquireGeneratorTracker(StringRef generatorName, SourceLineInfo const& lineInfo ) {
+++ return getResultCapture().acquireGeneratorTracker( generatorName, lineInfo );
+++ }
+++
+++ IGeneratorTracker* createGeneratorTracker( StringRef generatorName,
+++ SourceLineInfo lineInfo,
+++ GeneratorBasePtr&& generator ) {
+++ return getResultCapture().createGeneratorTracker(
+++ generatorName, lineInfo, CATCH_MOVE( generator ) );
+++ }
+++
+++} // namespace Generators
+++} // namespace Catch
+++
+++
+++
+++
+++#include <random>
+++
+++namespace Catch {
+++ namespace Generators {
+++ namespace Detail {
+++ std::uint32_t getSeed() { return sharedRng()(); }
+++ } // namespace Detail
+++
+++ struct RandomFloatingGenerator<long double>::PImpl {
+++ PImpl( long double a, long double b, uint32_t seed ):
+++ rng( seed ), dist( a, b ) {}
+++
+++ Catch::SimplePcg32 rng;
+++ std::uniform_real_distribution<long double> dist;
+++ };
+++
+++ RandomFloatingGenerator<long double>::RandomFloatingGenerator(
+++ long double a, long double b, std::uint32_t seed) :
+++ m_pimpl(Catch::Detail::make_unique<PImpl>(a, b, seed)) {
+++ static_cast<void>( next() );
+++ }
+++
+++ RandomFloatingGenerator<long double>::~RandomFloatingGenerator() =
+++ default;
+++ bool RandomFloatingGenerator<long double>::next() {
+++ m_current_number = m_pimpl->dist( m_pimpl->rng );
+++ return true;
+++ }
+++ } // namespace Generators
+++} // namespace Catch
+++
+++
+++
+++
+++namespace Catch {
+++ IResultCapture::~IResultCapture() = default;
+++}
+++
+++
+++
+++
+++namespace Catch {
+++ IConfig::~IConfig() = default;
+++}
+++
+++
+++
+++
+++namespace Catch {
+++ IExceptionTranslator::~IExceptionTranslator() = default;
+++ IExceptionTranslatorRegistry::~IExceptionTranslatorRegistry() = default;
+++}
+++
+++
+++
+++#include <string>
+++
+++namespace Catch {
+++ namespace Generators {
+++
+++ bool GeneratorUntypedBase::countedNext() {
+++ auto ret = next();
+++ if ( ret ) {
+++ m_stringReprCache.clear();
+++ ++m_currentElementIndex;
+++ }
+++ return ret;
+++ }
+++
+++ StringRef GeneratorUntypedBase::currentElementAsString() const {
+++ if ( m_stringReprCache.empty() ) {
+++ m_stringReprCache = stringifyImpl();
+++ }
+++ return m_stringReprCache;
+++ }
+++
+++ } // namespace Generators
+++} // namespace Catch
+++
+++
+++
+++
+++namespace Catch {
+++ IRegistryHub::~IRegistryHub() = default;
+++ IMutableRegistryHub::~IMutableRegistryHub() = default;
+++}
+++
+++
+++
+++#include <cassert>
+++
+++namespace Catch {
+++
+++ ReporterConfig::ReporterConfig(
+++ IConfig const* _fullConfig,
+++ Detail::unique_ptr<IStream> _stream,
+++ ColourMode colourMode,
+++ std::map<std::string, std::string> customOptions ):
+++ m_stream( CATCH_MOVE(_stream) ),
+++ m_fullConfig( _fullConfig ),
+++ m_colourMode( colourMode ),
+++ m_customOptions( CATCH_MOVE( customOptions ) ) {}
+++
+++ Detail::unique_ptr<IStream> ReporterConfig::takeStream() && {
+++ assert( m_stream );
+++ return CATCH_MOVE( m_stream );
+++ }
+++ IConfig const * ReporterConfig::fullConfig() const { return m_fullConfig; }
+++ ColourMode ReporterConfig::colourMode() const { return m_colourMode; }
+++
+++ std::map<std::string, std::string> const&
+++ ReporterConfig::customOptions() const {
+++ return m_customOptions;
+++ }
+++
+++ ReporterConfig::~ReporterConfig() = default;
+++
+++ AssertionStats::AssertionStats( AssertionResult const& _assertionResult,
+++ std::vector<MessageInfo> const& _infoMessages,
+++ Totals const& _totals )
+++ : assertionResult( _assertionResult ),
+++ infoMessages( _infoMessages ),
+++ totals( _totals )
+++ {
+++ if( assertionResult.hasMessage() ) {
+++ // Copy message into messages list.
+++ // !TBD This should have been done earlier, somewhere
+++ MessageBuilder builder( assertionResult.getTestMacroName(), assertionResult.getSourceInfo(), assertionResult.getResultType() );
+++ builder.m_info.message = static_cast<std::string>(assertionResult.getMessage());
+++
+++ infoMessages.push_back( CATCH_MOVE(builder.m_info) );
+++ }
+++ }
+++
+++ SectionStats::SectionStats( SectionInfo&& _sectionInfo,
+++ Counts const& _assertions,
+++ double _durationInSeconds,
+++ bool _missingAssertions )
+++ : sectionInfo( CATCH_MOVE(_sectionInfo) ),
+++ assertions( _assertions ),
+++ durationInSeconds( _durationInSeconds ),
+++ missingAssertions( _missingAssertions )
+++ {}
+++
+++
+++ TestCaseStats::TestCaseStats( TestCaseInfo const& _testInfo,
+++ Totals const& _totals,
+++ std::string&& _stdOut,
+++ std::string&& _stdErr,
+++ bool _aborting )
+++ : testInfo( &_testInfo ),
+++ totals( _totals ),
+++ stdOut( CATCH_MOVE(_stdOut) ),
+++ stdErr( CATCH_MOVE(_stdErr) ),
+++ aborting( _aborting )
+++ {}
+++
+++
+++ TestRunStats::TestRunStats( TestRunInfo const& _runInfo,
+++ Totals const& _totals,
+++ bool _aborting )
+++ : runInfo( _runInfo ),
+++ totals( _totals ),
+++ aborting( _aborting )
+++ {}
+++
+++ IEventListener::~IEventListener() = default;
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++namespace Catch {
+++ IReporterFactory::~IReporterFactory() = default;
+++ EventListenerFactory::~EventListenerFactory() = default;
+++}
+++
+++
+++
+++
+++namespace Catch {
+++ ITestCaseRegistry::~ITestCaseRegistry() = default;
+++}
+++
+++
+++
+++namespace Catch {
+++
+++ AssertionHandler::AssertionHandler
+++ ( StringRef macroName,
+++ SourceLineInfo const& lineInfo,
+++ StringRef capturedExpression,
+++ ResultDisposition::Flags resultDisposition )
+++ : m_assertionInfo{ macroName, lineInfo, capturedExpression, resultDisposition },
+++ m_resultCapture( getResultCapture() )
+++ {
+++ m_resultCapture.notifyAssertionStarted( m_assertionInfo );
+++ }
+++
+++ void AssertionHandler::handleExpr( ITransientExpression const& expr ) {
+++ m_resultCapture.handleExpr( m_assertionInfo, expr, m_reaction );
+++ }
+++ void AssertionHandler::handleMessage(ResultWas::OfType resultType, StringRef message) {
+++ m_resultCapture.handleMessage( m_assertionInfo, resultType, message, m_reaction );
+++ }
+++
+++ auto AssertionHandler::allowThrows() const -> bool {
+++ return getCurrentContext().getConfig()->allowThrows();
+++ }
+++
+++ void AssertionHandler::complete() {
+++ m_completed = true;
+++ if( m_reaction.shouldDebugBreak ) {
+++
+++ // If you find your debugger stopping you here then go one level up on the
+++ // call-stack for the code that caused it (typically a failed assertion)
+++
+++ // (To go back to the test and change execution, jump over the throw, next)
+++ CATCH_BREAK_INTO_DEBUGGER();
+++ }
+++ if (m_reaction.shouldThrow) {
+++ throw_test_failure_exception();
+++ }
+++ if ( m_reaction.shouldSkip ) {
+++ throw_test_skip_exception();
+++ }
+++ }
+++
+++ void AssertionHandler::handleUnexpectedInflightException() {
+++ m_resultCapture.handleUnexpectedInflightException( m_assertionInfo, Catch::translateActiveException(), m_reaction );
+++ }
+++
+++ void AssertionHandler::handleExceptionThrownAsExpected() {
+++ m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+++ }
+++ void AssertionHandler::handleExceptionNotThrownAsExpected() {
+++ m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+++ }
+++
+++ void AssertionHandler::handleUnexpectedExceptionNotThrown() {
+++ m_resultCapture.handleUnexpectedExceptionNotThrown( m_assertionInfo, m_reaction );
+++ }
+++
+++ void AssertionHandler::handleThrowingCallSkipped() {
+++ m_resultCapture.handleNonExpr(m_assertionInfo, ResultWas::Ok, m_reaction);
+++ }
+++
+++ // This is the overload that takes a string and infers the Equals matcher from it
+++ // The more general overload, that takes any string matcher, is in catch_capture_matchers.cpp
+++ void handleExceptionMatchExpr( AssertionHandler& handler, std::string const& str ) {
+++ handleExceptionMatchExpr( handler, Matchers::Equals( str ) );
+++ }
+++
+++} // namespace Catch
+++
+++
+++
+++
+++#include <algorithm>
+++
+++namespace Catch {
+++ namespace Detail {
+++
+++ bool CaseInsensitiveLess::operator()( StringRef lhs,
+++ StringRef rhs ) const {
+++ return std::lexicographical_compare(
+++ lhs.begin(), lhs.end(),
+++ rhs.begin(), rhs.end(),
+++ []( char l, char r ) { return toLower( l ) < toLower( r ); } );
+++ }
+++
+++ bool
+++ CaseInsensitiveEqualTo::operator()( StringRef lhs,
+++ StringRef rhs ) const {
+++ return std::equal(
+++ lhs.begin(), lhs.end(),
+++ rhs.begin(), rhs.end(),
+++ []( char l, char r ) { return toLower( l ) == toLower( r ); } );
+++ }
+++
+++ } // namespace Detail
+++} // namespace Catch
+++
+++
+++
+++
+++#include <algorithm>
+++#include <ostream>
+++
+++namespace {
+++ bool isOptPrefix( char c ) {
+++ return c == '-'
+++#ifdef CATCH_PLATFORM_WINDOWS
+++ || c == '/'
+++#endif
+++ ;
+++ }
+++
+++ Catch::StringRef normaliseOpt( Catch::StringRef optName ) {
+++ if ( optName[0] == '-'
+++#if defined(CATCH_PLATFORM_WINDOWS)
+++ || optName[0] == '/'
+++#endif
+++ ) {
+++ return optName.substr( 1, optName.size() );
+++ }
+++
+++ return optName;
+++ }
+++
+++ static size_t find_first_separator(Catch::StringRef sr) {
+++ auto is_separator = []( char c ) {
+++ return c == ' ' || c == ':' || c == '=';
+++ };
+++ size_t pos = 0;
+++ while (pos < sr.size()) {
+++ if (is_separator(sr[pos])) { return pos; }
+++ ++pos;
+++ }
+++
+++ return Catch::StringRef::npos;
+++ }
+++
+++} // namespace
+++
+++namespace Catch {
+++ namespace Clara {
+++ namespace Detail {
+++
+++ void TokenStream::loadBuffer() {
+++ m_tokenBuffer.clear();
+++
+++ // Skip any empty strings
+++ while ( it != itEnd && it->empty() ) {
+++ ++it;
+++ }
+++
+++ if ( it != itEnd ) {
+++ StringRef next = *it;
+++ if ( isOptPrefix( next[0] ) ) {
+++ auto delimiterPos = find_first_separator(next);
+++ if ( delimiterPos != StringRef::npos ) {
+++ m_tokenBuffer.push_back(
+++ { TokenType::Option,
+++ next.substr( 0, delimiterPos ) } );
+++ m_tokenBuffer.push_back(
+++ { TokenType::Argument,
+++ next.substr( delimiterPos + 1, next.size() ) } );
+++ } else {
+++ if ( next[1] != '-' && next.size() > 2 ) {
+++ // Combined short args, e.g. "-ab" for "-a -b"
+++ for ( size_t i = 1; i < next.size(); ++i ) {
+++ m_tokenBuffer.push_back(
+++ { TokenType::Option,
+++ next.substr( i, 1 ) } );
+++ }
+++ } else {
+++ m_tokenBuffer.push_back(
+++ { TokenType::Option, next } );
+++ }
+++ }
+++ } else {
+++ m_tokenBuffer.push_back(
+++ { TokenType::Argument, next } );
+++ }
+++ }
+++ }
+++
+++ TokenStream::TokenStream( Args const& args ):
+++ TokenStream( args.m_args.begin(), args.m_args.end() ) {}
+++
+++ TokenStream::TokenStream( Iterator it_, Iterator itEnd_ ):
+++ it( it_ ), itEnd( itEnd_ ) {
+++ loadBuffer();
+++ }
+++
+++ TokenStream& TokenStream::operator++() {
+++ if ( m_tokenBuffer.size() >= 2 ) {
+++ m_tokenBuffer.erase( m_tokenBuffer.begin() );
+++ } else {
+++ if ( it != itEnd )
+++ ++it;
+++ loadBuffer();
+++ }
+++ return *this;
+++ }
+++
+++ ParserResult convertInto( std::string const& source,
+++ std::string& target ) {
+++ target = source;
+++ return ParserResult::ok( ParseResultType::Matched );
+++ }
+++
+++ ParserResult convertInto( std::string const& source,
+++ bool& target ) {
+++ std::string srcLC = toLower( source );
+++
+++ if ( srcLC == "y" || srcLC == "1" || srcLC == "true" ||
+++ srcLC == "yes" || srcLC == "on" ) {
+++ target = true;
+++ } else if ( srcLC == "n" || srcLC == "0" || srcLC == "false" ||
+++ srcLC == "no" || srcLC == "off" ) {
+++ target = false;
+++ } else {
+++ return ParserResult::runtimeError(
+++ "Expected a boolean value but did not recognise: '" +
+++ source + '\'' );
+++ }
+++ return ParserResult::ok( ParseResultType::Matched );
+++ }
+++
+++ size_t ParserBase::cardinality() const { return 1; }
+++
+++ InternalParseResult ParserBase::parse( Args const& args ) const {
+++ return parse( static_cast<std::string>(args.exeName()), TokenStream( args ) );
+++ }
+++
+++ ParseState::ParseState( ParseResultType type,
+++ TokenStream remainingTokens ):
+++ m_type( type ), m_remainingTokens( CATCH_MOVE(remainingTokens) ) {}
+++
+++ ParserResult BoundFlagRef::setFlag( bool flag ) {
+++ m_ref = flag;
+++ return ParserResult::ok( ParseResultType::Matched );
+++ }
+++
+++ ResultBase::~ResultBase() = default;
+++
+++ bool BoundRef::isContainer() const { return false; }
+++
+++ bool BoundRef::isFlag() const { return false; }
+++
+++ bool BoundFlagRefBase::isFlag() const { return true; }
+++
+++} // namespace Detail
+++
+++ Detail::InternalParseResult Arg::parse(std::string const&,
+++ Detail::TokenStream tokens) const {
+++ auto validationResult = validate();
+++ if (!validationResult)
+++ return Detail::InternalParseResult(validationResult);
+++
+++ auto token = *tokens;
+++ if (token.type != Detail::TokenType::Argument)
+++ return Detail::InternalParseResult::ok(Detail::ParseState(
+++ ParseResultType::NoMatch, CATCH_MOVE(tokens)));
+++
+++ assert(!m_ref->isFlag());
+++ auto valueRef =
+++ static_cast<Detail::BoundValueRefBase*>(m_ref.get());
+++
+++ auto result = valueRef->setValue(static_cast<std::string>(token.token));
+++ if ( !result )
+++ return Detail::InternalParseResult( result );
+++ else
+++ return Detail::InternalParseResult::ok(
+++ Detail::ParseState( ParseResultType::Matched,
+++ CATCH_MOVE( ++tokens ) ) );
+++ }
+++
+++ Opt::Opt(bool& ref) :
+++ ParserRefImpl(std::make_shared<Detail::BoundFlagRef>(ref)) {}
+++
+++ Detail::HelpColumns Opt::getHelpColumns() const {
+++ ReusableStringStream oss;
+++ bool first = true;
+++ for (auto const& opt : m_optNames) {
+++ if (first)
+++ first = false;
+++ else
+++ oss << ", ";
+++ oss << opt;
+++ }
+++ if (!m_hint.empty())
+++ oss << " <" << m_hint << '>';
+++ return { oss.str(), m_description };
+++ }
+++
+++ bool Opt::isMatch(StringRef optToken) const {
+++ auto normalisedToken = normaliseOpt(optToken);
+++ for (auto const& name : m_optNames) {
+++ if (normaliseOpt(name) == normalisedToken)
+++ return true;
+++ }
+++ return false;
+++ }
+++
+++ Detail::InternalParseResult Opt::parse(std::string const&,
+++ Detail::TokenStream tokens) const {
+++ auto validationResult = validate();
+++ if (!validationResult)
+++ return Detail::InternalParseResult(validationResult);
+++
+++ if (tokens &&
+++ tokens->type == Detail::TokenType::Option) {
+++ auto const& token = *tokens;
+++ if (isMatch(token.token)) {
+++ if (m_ref->isFlag()) {
+++ auto flagRef =
+++ static_cast<Detail::BoundFlagRefBase*>(
+++ m_ref.get());
+++ auto result = flagRef->setFlag(true);
+++ if (!result)
+++ return Detail::InternalParseResult(result);
+++ if (result.value() ==
+++ ParseResultType::ShortCircuitAll)
+++ return Detail::InternalParseResult::ok(Detail::ParseState(
+++ result.value(), CATCH_MOVE(tokens)));
+++ } else {
+++ auto valueRef =
+++ static_cast<Detail::BoundValueRefBase*>(
+++ m_ref.get());
+++ ++tokens;
+++ if (!tokens)
+++ return Detail::InternalParseResult::runtimeError(
+++ "Expected argument following " +
+++ token.token);
+++ auto const& argToken = *tokens;
+++ if (argToken.type != Detail::TokenType::Argument)
+++ return Detail::InternalParseResult::runtimeError(
+++ "Expected argument following " +
+++ token.token);
+++ const auto result = valueRef->setValue(static_cast<std::string>(argToken.token));
+++ if (!result)
+++ return Detail::InternalParseResult(result);
+++ if (result.value() ==
+++ ParseResultType::ShortCircuitAll)
+++ return Detail::InternalParseResult::ok(Detail::ParseState(
+++ result.value(), CATCH_MOVE(tokens)));
+++ }
+++ return Detail::InternalParseResult::ok(Detail::ParseState(
+++ ParseResultType::Matched, CATCH_MOVE(++tokens)));
+++ }
+++ }
+++ return Detail::InternalParseResult::ok(
+++ Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens)));
+++ }
+++
+++ Detail::Result Opt::validate() const {
+++ if (m_optNames.empty())
+++ return Detail::Result::logicError("No options supplied to Opt");
+++ for (auto const& name : m_optNames) {
+++ if (name.empty())
+++ return Detail::Result::logicError(
+++ "Option name cannot be empty");
+++#ifdef CATCH_PLATFORM_WINDOWS
+++ if (name[0] != '-' && name[0] != '/')
+++ return Detail::Result::logicError(
+++ "Option name must begin with '-' or '/'");
+++#else
+++ if (name[0] != '-')
+++ return Detail::Result::logicError(
+++ "Option name must begin with '-'");
+++#endif
+++ }
+++ return ParserRefImpl::validate();
+++ }
+++
+++ ExeName::ExeName() :
+++ m_name(std::make_shared<std::string>("<executable>")) {}
+++
+++ ExeName::ExeName(std::string& ref) : ExeName() {
+++ m_ref = std::make_shared<Detail::BoundValueRef<std::string>>(ref);
+++ }
+++
+++ Detail::InternalParseResult
+++ ExeName::parse(std::string const&,
+++ Detail::TokenStream tokens) const {
+++ return Detail::InternalParseResult::ok(
+++ Detail::ParseState(ParseResultType::NoMatch, CATCH_MOVE(tokens)));
+++ }
+++
+++ ParserResult ExeName::set(std::string const& newName) {
+++ auto lastSlash = newName.find_last_of("\\/");
+++ auto filename = (lastSlash == std::string::npos)
+++ ? newName
+++ : newName.substr(lastSlash + 1);
+++
+++ *m_name = filename;
+++ if (m_ref)
+++ return m_ref->setValue(filename);
+++ else
+++ return ParserResult::ok(ParseResultType::Matched);
+++ }
+++
+++
+++
+++
+++ Parser& Parser::operator|=( Parser const& other ) {
+++ m_options.insert( m_options.end(),
+++ other.m_options.begin(),
+++ other.m_options.end() );
+++ m_args.insert(
+++ m_args.end(), other.m_args.begin(), other.m_args.end() );
+++ return *this;
+++ }
+++
+++ std::vector<Detail::HelpColumns> Parser::getHelpColumns() const {
+++ std::vector<Detail::HelpColumns> cols;
+++ cols.reserve( m_options.size() );
+++ for ( auto const& o : m_options ) {
+++ cols.push_back(o.getHelpColumns());
+++ }
+++ return cols;
+++ }
+++
+++ void Parser::writeToStream( std::ostream& os ) const {
+++ if ( !m_exeName.name().empty() ) {
+++ os << "usage:\n"
+++ << " " << m_exeName.name() << ' ';
+++ bool required = true, first = true;
+++ for ( auto const& arg : m_args ) {
+++ if ( first )
+++ first = false;
+++ else
+++ os << ' ';
+++ if ( arg.isOptional() && required ) {
+++ os << '[';
+++ required = false;
+++ }
+++ os << '<' << arg.hint() << '>';
+++ if ( arg.cardinality() == 0 )
+++ os << " ... ";
+++ }
+++ if ( !required )
+++ os << ']';
+++ if ( !m_options.empty() )
+++ os << " options";
+++ os << "\n\nwhere options are:\n";
+++ }
+++
+++ auto rows = getHelpColumns();
+++ size_t consoleWidth = CATCH_CONFIG_CONSOLE_WIDTH;
+++ size_t optWidth = 0;
+++ for ( auto const& cols : rows )
+++ optWidth = ( std::max )( optWidth, cols.left.size() + 2 );
+++
+++ optWidth = ( std::min )( optWidth, consoleWidth / 2 );
+++
+++ for ( auto& cols : rows ) {
+++ auto row = TextFlow::Column( CATCH_MOVE(cols.left) )
+++ .width( optWidth )
+++ .indent( 2 ) +
+++ TextFlow::Spacer( 4 ) +
+++ TextFlow::Column( static_cast<std::string>(cols.descriptions) )
+++ .width( consoleWidth - 7 - optWidth );
+++ os << row << '\n';
+++ }
+++ }
+++
+++ Detail::Result Parser::validate() const {
+++ for ( auto const& opt : m_options ) {
+++ auto result = opt.validate();
+++ if ( !result )
+++ return result;
+++ }
+++ for ( auto const& arg : m_args ) {
+++ auto result = arg.validate();
+++ if ( !result )
+++ return result;
+++ }
+++ return Detail::Result::ok();
+++ }
+++
+++ Detail::InternalParseResult
+++ Parser::parse( std::string const& exeName,
+++ Detail::TokenStream tokens ) const {
+++
+++ struct ParserInfo {
+++ ParserBase const* parser = nullptr;
+++ size_t count = 0;
+++ };
+++ std::vector<ParserInfo> parseInfos;
+++ parseInfos.reserve( m_options.size() + m_args.size() );
+++ for ( auto const& opt : m_options ) {
+++ parseInfos.push_back( { &opt, 0 } );
+++ }
+++ for ( auto const& arg : m_args ) {
+++ parseInfos.push_back( { &arg, 0 } );
+++ }
+++
+++ m_exeName.set( exeName );
+++
+++ auto result = Detail::InternalParseResult::ok(
+++ Detail::ParseState( ParseResultType::NoMatch, CATCH_MOVE(tokens) ) );
+++ while ( result.value().remainingTokens() ) {
+++ bool tokenParsed = false;
+++
+++ for ( auto& parseInfo : parseInfos ) {
+++ if ( parseInfo.parser->cardinality() == 0 ||
+++ parseInfo.count < parseInfo.parser->cardinality() ) {
+++ result = parseInfo.parser->parse(
+++ exeName, CATCH_MOVE(result).value().remainingTokens() );
+++ if ( !result )
+++ return result;
+++ if ( result.value().type() !=
+++ ParseResultType::NoMatch ) {
+++ tokenParsed = true;
+++ ++parseInfo.count;
+++ break;
+++ }
+++ }
+++ }
+++
+++ if ( result.value().type() == ParseResultType::ShortCircuitAll )
+++ return result;
+++ if ( !tokenParsed )
+++ return Detail::InternalParseResult::runtimeError(
+++ "Unrecognised token: " +
+++ result.value().remainingTokens()->token );
+++ }
+++ // !TBD Check missing required options
+++ return result;
+++ }
+++
+++ Args::Args(int argc, char const* const* argv) :
+++ m_exeName(argv[0]), m_args(argv + 1, argv + argc) {}
+++
+++ Args::Args(std::initializer_list<StringRef> args) :
+++ m_exeName(*args.begin()),
+++ m_args(args.begin() + 1, args.end()) {}
+++
+++
+++ Help::Help( bool& showHelpFlag ):
+++ Opt( [&]( bool flag ) {
+++ showHelpFlag = flag;
+++ return ParserResult::ok( ParseResultType::ShortCircuitAll );
+++ } ) {
+++ static_cast<Opt&> ( *this )(
+++ "display usage information" )["-?"]["-h"]["--help"]
+++ .optional();
+++ }
+++
+++ } // namespace Clara
+++} // namespace Catch
+++
+++
+++
+++
+++#include <fstream>
+++#include <string>
+++
+++namespace Catch {
+++
+++ Clara::Parser makeCommandLineParser( ConfigData& config ) {
+++
+++ using namespace Clara;
+++
+++ auto const setWarning = [&]( std::string const& warning ) {
+++ if ( warning == "NoAssertions" ) {
+++ config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::NoAssertions);
+++ return ParserResult::ok( ParseResultType::Matched );
+++ } else if ( warning == "UnmatchedTestSpec" ) {
+++ config.warnings = static_cast<WarnAbout::What>(config.warnings | WarnAbout::UnmatchedTestSpec);
+++ return ParserResult::ok( ParseResultType::Matched );
+++ }
+++
+++ return ParserResult ::runtimeError(
+++ "Unrecognised warning option: '" + warning + '\'' );
+++ };
+++ auto const loadTestNamesFromFile = [&]( std::string const& filename ) {
+++ std::ifstream f( filename.c_str() );
+++ if( !f.is_open() )
+++ return ParserResult::runtimeError( "Unable to load input file: '" + filename + '\'' );
+++
+++ std::string line;
+++ while( std::getline( f, line ) ) {
+++ line = trim(line);
+++ if( !line.empty() && !startsWith( line, '#' ) ) {
+++ if( !startsWith( line, '"' ) )
+++ line = '"' + CATCH_MOVE(line) + '"';
+++ config.testsOrTags.push_back( line );
+++ config.testsOrTags.emplace_back( "," );
+++ }
+++ }
+++ //Remove comma in the end
+++ if(!config.testsOrTags.empty())
+++ config.testsOrTags.erase( config.testsOrTags.end()-1 );
+++
+++ return ParserResult::ok( ParseResultType::Matched );
+++ };
+++ auto const setTestOrder = [&]( std::string const& order ) {
+++ if( startsWith( "declared", order ) )
+++ config.runOrder = TestRunOrder::Declared;
+++ else if( startsWith( "lexical", order ) )
+++ config.runOrder = TestRunOrder::LexicographicallySorted;
+++ else if( startsWith( "random", order ) )
+++ config.runOrder = TestRunOrder::Randomized;
+++ else
+++ return ParserResult::runtimeError( "Unrecognised ordering: '" + order + '\'' );
+++ return ParserResult::ok( ParseResultType::Matched );
+++ };
+++ auto const setRngSeed = [&]( std::string const& seed ) {
+++ if( seed == "time" ) {
+++ config.rngSeed = generateRandomSeed(GenerateFrom::Time);
+++ return ParserResult::ok(ParseResultType::Matched);
+++ } else if (seed == "random-device") {
+++ config.rngSeed = generateRandomSeed(GenerateFrom::RandomDevice);
+++ return ParserResult::ok(ParseResultType::Matched);
+++ }
+++
+++ // TODO: ideally we should be parsing uint32_t directly
+++ // fix this later when we add new parse overload
+++ auto parsedSeed = parseUInt( seed, 0 );
+++ if ( !parsedSeed ) {
+++ return ParserResult::runtimeError( "Could not parse '" + seed + "' as seed" );
+++ }
+++ config.rngSeed = *parsedSeed;
+++ return ParserResult::ok( ParseResultType::Matched );
+++ };
+++ auto const setDefaultColourMode = [&]( std::string const& colourMode ) {
+++ Optional<ColourMode> maybeMode = Catch::Detail::stringToColourMode(toLower( colourMode ));
+++ if ( !maybeMode ) {
+++ return ParserResult::runtimeError(
+++ "colour mode must be one of: default, ansi, win32, "
+++ "or none. '" +
+++ colourMode + "' is not recognised" );
+++ }
+++ auto mode = *maybeMode;
+++ if ( !isColourImplAvailable( mode ) ) {
+++ return ParserResult::runtimeError(
+++ "colour mode '" + colourMode +
+++ "' is not supported in this binary" );
+++ }
+++ config.defaultColourMode = mode;
+++ return ParserResult::ok( ParseResultType::Matched );
+++ };
+++ auto const setWaitForKeypress = [&]( std::string const& keypress ) {
+++ auto keypressLc = toLower( keypress );
+++ if (keypressLc == "never")
+++ config.waitForKeypress = WaitForKeypress::Never;
+++ else if( keypressLc == "start" )
+++ config.waitForKeypress = WaitForKeypress::BeforeStart;
+++ else if( keypressLc == "exit" )
+++ config.waitForKeypress = WaitForKeypress::BeforeExit;
+++ else if( keypressLc == "both" )
+++ config.waitForKeypress = WaitForKeypress::BeforeStartAndExit;
+++ else
+++ return ParserResult::runtimeError( "keypress argument must be one of: never, start, exit or both. '" + keypress + "' not recognised" );
+++ return ParserResult::ok( ParseResultType::Matched );
+++ };
+++ auto const setVerbosity = [&]( std::string const& verbosity ) {
+++ auto lcVerbosity = toLower( verbosity );
+++ if( lcVerbosity == "quiet" )
+++ config.verbosity = Verbosity::Quiet;
+++ else if( lcVerbosity == "normal" )
+++ config.verbosity = Verbosity::Normal;
+++ else if( lcVerbosity == "high" )
+++ config.verbosity = Verbosity::High;
+++ else
+++ return ParserResult::runtimeError( "Unrecognised verbosity, '" + verbosity + '\'' );
+++ return ParserResult::ok( ParseResultType::Matched );
+++ };
+++ auto const setReporter = [&]( std::string const& userReporterSpec ) {
+++ if ( userReporterSpec.empty() ) {
+++ return ParserResult::runtimeError( "Received empty reporter spec." );
+++ }
+++
+++ Optional<ReporterSpec> parsed =
+++ parseReporterSpec( userReporterSpec );
+++ if ( !parsed ) {
+++ return ParserResult::runtimeError(
+++ "Could not parse reporter spec '" + userReporterSpec +
+++ "'" );
+++ }
+++
+++ auto const& reporterSpec = *parsed;
+++
+++ auto const& factories =
+++ getRegistryHub().getReporterRegistry().getFactories();
+++ auto result = factories.find( reporterSpec.name() );
+++
+++ if ( result == factories.end() ) {
+++ return ParserResult::runtimeError(
+++ "Unrecognized reporter, '" + reporterSpec.name() +
+++ "'. Check available with --list-reporters" );
+++ }
+++
+++
+++ const bool hadOutputFile = reporterSpec.outputFile().some();
+++ config.reporterSpecifications.push_back( CATCH_MOVE( *parsed ) );
+++ // It would be enough to check this only once at the very end, but
+++ // there is not a place where we could call this check, so do it
+++ // every time it could fail. For valid inputs, this is still called
+++ // at most once.
+++ if (!hadOutputFile) {
+++ int n_reporters_without_file = 0;
+++ for (auto const& spec : config.reporterSpecifications) {
+++ if (spec.outputFile().none()) {
+++ n_reporters_without_file++;
+++ }
+++ }
+++ if (n_reporters_without_file > 1) {
+++ return ParserResult::runtimeError( "Only one reporter may have unspecified output file." );
+++ }
+++ }
+++
+++ return ParserResult::ok( ParseResultType::Matched );
+++ };
+++ auto const setShardCount = [&]( std::string const& shardCount ) {
+++ auto parsedCount = parseUInt( shardCount );
+++ if ( !parsedCount ) {
+++ return ParserResult::runtimeError(
+++ "Could not parse '" + shardCount + "' as shard count" );
+++ }
+++ if ( *parsedCount == 0 ) {
+++ return ParserResult::runtimeError(
+++ "Shard count must be positive" );
+++ }
+++ config.shardCount = *parsedCount;
+++ return ParserResult::ok( ParseResultType::Matched );
+++ };
+++
+++ auto const setShardIndex = [&](std::string const& shardIndex) {
+++ auto parsedIndex = parseUInt( shardIndex );
+++ if ( !parsedIndex ) {
+++ return ParserResult::runtimeError(
+++ "Could not parse '" + shardIndex + "' as shard index" );
+++ }
+++ config.shardIndex = *parsedIndex;
+++ return ParserResult::ok( ParseResultType::Matched );
+++ };
+++
+++ auto cli
+++ = ExeName( config.processName )
+++ | Help( config.showHelp )
+++ | Opt( config.showSuccessfulTests )
+++ ["-s"]["--success"]
+++ ( "include successful tests in output" )
+++ | Opt( config.shouldDebugBreak )
+++ ["-b"]["--break"]
+++ ( "break into debugger on failure" )
+++ | Opt( config.noThrow )
+++ ["-e"]["--nothrow"]
+++ ( "skip exception tests" )
+++ | Opt( config.showInvisibles )
+++ ["-i"]["--invisibles"]
+++ ( "show invisibles (tabs, newlines)" )
+++ | Opt( config.defaultOutputFilename, "filename" )
+++ ["-o"]["--out"]
+++ ( "default output filename" )
+++ | Opt( accept_many, setReporter, "name[::key=value]*" )
+++ ["-r"]["--reporter"]
+++ ( "reporter to use (defaults to console)" )
+++ | Opt( config.name, "name" )
+++ ["-n"]["--name"]
+++ ( "suite name" )
+++ | Opt( [&]( bool ){ config.abortAfter = 1; } )
+++ ["-a"]["--abort"]
+++ ( "abort at first failure" )
+++ | Opt( [&]( int x ){ config.abortAfter = x; }, "no. failures" )
+++ ["-x"]["--abortx"]
+++ ( "abort after x failures" )
+++ | Opt( accept_many, setWarning, "warning name" )
+++ ["-w"]["--warn"]
+++ ( "enable warnings" )
+++ | Opt( [&]( bool flag ) { config.showDurations = flag ? ShowDurations::Always : ShowDurations::Never; }, "yes|no" )
+++ ["-d"]["--durations"]
+++ ( "show test durations" )
+++ | Opt( config.minDuration, "seconds" )
+++ ["-D"]["--min-duration"]
+++ ( "show test durations for tests taking at least the given number of seconds" )
+++ | Opt( loadTestNamesFromFile, "filename" )
+++ ["-f"]["--input-file"]
+++ ( "load test names to run from a file" )
+++ | Opt( config.filenamesAsTags )
+++ ["-#"]["--filenames-as-tags"]
+++ ( "adds a tag for the filename" )
+++ | Opt( config.sectionsToRun, "section name" )
+++ ["-c"]["--section"]
+++ ( "specify section to run" )
+++ | Opt( setVerbosity, "quiet|normal|high" )
+++ ["-v"]["--verbosity"]
+++ ( "set output verbosity" )
+++ | Opt( config.listTests )
+++ ["--list-tests"]
+++ ( "list all/matching test cases" )
+++ | Opt( config.listTags )
+++ ["--list-tags"]
+++ ( "list all/matching tags" )
+++ | Opt( config.listReporters )
+++ ["--list-reporters"]
+++ ( "list all available reporters" )
+++ | Opt( config.listListeners )
+++ ["--list-listeners"]
+++ ( "list all listeners" )
+++ | Opt( setTestOrder, "decl|lex|rand" )
+++ ["--order"]
+++ ( "test case order (defaults to decl)" )
+++ | Opt( setRngSeed, "'time'|'random-device'|number" )
+++ ["--rng-seed"]
+++ ( "set a specific seed for random numbers" )
+++ | Opt( setDefaultColourMode, "ansi|win32|none|default" )
+++ ["--colour-mode"]
+++ ( "what color mode should be used as default" )
+++ | Opt( config.libIdentify )
+++ ["--libidentify"]
+++ ( "report name and version according to libidentify standard" )
+++ | Opt( setWaitForKeypress, "never|start|exit|both" )
+++ ["--wait-for-keypress"]
+++ ( "waits for a keypress before exiting" )
+++ | Opt( config.skipBenchmarks)
+++ ["--skip-benchmarks"]
+++ ( "disable running benchmarks")
+++ | Opt( config.benchmarkSamples, "samples" )
+++ ["--benchmark-samples"]
+++ ( "number of samples to collect (default: 100)" )
+++ | Opt( config.benchmarkResamples, "resamples" )
+++ ["--benchmark-resamples"]
+++ ( "number of resamples for the bootstrap (default: 100000)" )
+++ | Opt( config.benchmarkConfidenceInterval, "confidence interval" )
+++ ["--benchmark-confidence-interval"]
+++ ( "confidence interval for the bootstrap (between 0 and 1, default: 0.95)" )
+++ | Opt( config.benchmarkNoAnalysis )
+++ ["--benchmark-no-analysis"]
+++ ( "perform only measurements; do not perform any analysis" )
+++ | Opt( config.benchmarkWarmupTime, "benchmarkWarmupTime" )
+++ ["--benchmark-warmup-time"]
+++ ( "amount of time in milliseconds spent on warming up each test (default: 100)" )
+++ | Opt( setShardCount, "shard count" )
+++ ["--shard-count"]
+++ ( "split the tests to execute into this many groups" )
+++ | Opt( setShardIndex, "shard index" )
+++ ["--shard-index"]
+++ ( "index of the group of tests to execute (see --shard-count)" )
+++ | Opt( config.allowZeroTests )
+++ ["--allow-running-no-tests"]
+++ ( "Treat 'No tests run' as a success" )
+++ | Arg( config.testsOrTags, "test name|pattern|tags" )
+++ ( "which test or tests to use" );
+++
+++ return cli;
+++ }
+++
+++} // end namespace Catch
+++
+++
+++#if defined(__clang__)
+++# pragma clang diagnostic push
+++# pragma clang diagnostic ignored "-Wexit-time-destructors"
+++#endif
+++
+++
+++
+++#include <cassert>
+++#include <ostream>
+++#include <utility>
+++
+++namespace Catch {
+++
+++ ColourImpl::~ColourImpl() = default;
+++
+++ ColourImpl::ColourGuard ColourImpl::guardColour( Colour::Code colourCode ) {
+++ return ColourGuard(colourCode, this );
+++ }
+++
+++ void ColourImpl::ColourGuard::engageImpl( std::ostream& stream ) {
+++ assert( &stream == &m_colourImpl->m_stream->stream() &&
+++ "Engaging colour guard for different stream than used by the "
+++ "parent colour implementation" );
+++ static_cast<void>( stream );
+++
+++ m_engaged = true;
+++ m_colourImpl->use( m_code );
+++ }
+++
+++ ColourImpl::ColourGuard::ColourGuard( Colour::Code code,
+++ ColourImpl const* colour ):
+++ m_colourImpl( colour ), m_code( code ) {
+++ }
+++ ColourImpl::ColourGuard::ColourGuard( ColourGuard&& rhs ) noexcept:
+++ m_colourImpl( rhs.m_colourImpl ),
+++ m_code( rhs.m_code ),
+++ m_engaged( rhs.m_engaged ) {
+++ rhs.m_engaged = false;
+++ }
+++ ColourImpl::ColourGuard&
+++ ColourImpl::ColourGuard::operator=( ColourGuard&& rhs ) noexcept {
+++ using std::swap;
+++ swap( m_colourImpl, rhs.m_colourImpl );
+++ swap( m_code, rhs.m_code );
+++ swap( m_engaged, rhs.m_engaged );
+++
+++ return *this;
+++ }
+++ ColourImpl::ColourGuard::~ColourGuard() {
+++ if ( m_engaged ) {
+++ m_colourImpl->use( Colour::None );
+++ }
+++ }
+++
+++ ColourImpl::ColourGuard&
+++ ColourImpl::ColourGuard::engage( std::ostream& stream ) & {
+++ engageImpl( stream );
+++ return *this;
+++ }
+++
+++ ColourImpl::ColourGuard&&
+++ ColourImpl::ColourGuard::engage( std::ostream& stream ) && {
+++ engageImpl( stream );
+++ return CATCH_MOVE(*this);
+++ }
+++
+++ namespace {
+++ //! A do-nothing implementation of colour, used as fallback for unknown
+++ //! platforms, and when the user asks to deactivate all colours.
+++ class NoColourImpl final : public ColourImpl {
+++ public:
+++ NoColourImpl( IStream* stream ): ColourImpl( stream ) {}
+++
+++ private:
+++ void use( Colour::Code ) const override {}
+++ };
+++ } // namespace
+++
+++
+++} // namespace Catch
+++
+++
+++#if defined ( CATCH_CONFIG_COLOUR_WIN32 ) /////////////////////////////////////////
+++
+++namespace Catch {
+++namespace {
+++
+++ class Win32ColourImpl final : public ColourImpl {
+++ public:
+++ Win32ColourImpl(IStream* stream):
+++ ColourImpl(stream) {
+++ CONSOLE_SCREEN_BUFFER_INFO csbiInfo;
+++ GetConsoleScreenBufferInfo( GetStdHandle( STD_OUTPUT_HANDLE ),
+++ &csbiInfo );
+++ originalForegroundAttributes = csbiInfo.wAttributes & ~( BACKGROUND_GREEN | BACKGROUND_RED | BACKGROUND_BLUE | BACKGROUND_INTENSITY );
+++ originalBackgroundAttributes = csbiInfo.wAttributes & ~( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE | FOREGROUND_INTENSITY );
+++ }
+++
+++ static bool useImplementationForStream(IStream const& stream) {
+++ // Win32 text colour APIs can only be used on console streams
+++ // We cannot check that the output hasn't been redirected,
+++ // so we just check that the original stream is console stream.
+++ return stream.isConsole();
+++ }
+++
+++ private:
+++ void use( Colour::Code _colourCode ) const override {
+++ switch( _colourCode ) {
+++ case Colour::None: return setTextAttribute( originalForegroundAttributes );
+++ case Colour::White: return setTextAttribute( FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+++ case Colour::Red: return setTextAttribute( FOREGROUND_RED );
+++ case Colour::Green: return setTextAttribute( FOREGROUND_GREEN );
+++ case Colour::Blue: return setTextAttribute( FOREGROUND_BLUE );
+++ case Colour::Cyan: return setTextAttribute( FOREGROUND_BLUE | FOREGROUND_GREEN );
+++ case Colour::Yellow: return setTextAttribute( FOREGROUND_RED | FOREGROUND_GREEN );
+++ case Colour::Grey: return setTextAttribute( 0 );
+++
+++ case Colour::LightGrey: return setTextAttribute( FOREGROUND_INTENSITY );
+++ case Colour::BrightRed: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED );
+++ case Colour::BrightGreen: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN );
+++ case Colour::BrightWhite: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_GREEN | FOREGROUND_RED | FOREGROUND_BLUE );
+++ case Colour::BrightYellow: return setTextAttribute( FOREGROUND_INTENSITY | FOREGROUND_RED | FOREGROUND_GREEN );
+++
+++ case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+++
+++ default:
+++ CATCH_ERROR( "Unknown colour requested" );
+++ }
+++ }
+++
+++ void setTextAttribute( WORD _textAttribute ) const {
+++ SetConsoleTextAttribute( GetStdHandle( STD_OUTPUT_HANDLE ),
+++ _textAttribute |
+++ originalBackgroundAttributes );
+++ }
+++ WORD originalForegroundAttributes;
+++ WORD originalBackgroundAttributes;
+++ };
+++
+++} // end anon namespace
+++} // end namespace Catch
+++
+++#endif // Windows/ ANSI/ None
+++
+++
+++#if defined( CATCH_PLATFORM_LINUX ) || defined( CATCH_PLATFORM_MAC )
+++# define CATCH_INTERNAL_HAS_ISATTY
+++# include <unistd.h>
+++#endif
+++
+++namespace Catch {
+++namespace {
+++
+++ class ANSIColourImpl final : public ColourImpl {
+++ public:
+++ ANSIColourImpl( IStream* stream ): ColourImpl( stream ) {}
+++
+++ static bool useImplementationForStream(IStream const& stream) {
+++ // This is kinda messy due to trying to support a bunch of
+++ // different platforms at once.
+++ // The basic idea is that if we are asked to do autodetection (as
+++ // opposed to being told to use posixy colours outright), then we
+++ // only want to use the colours if we are writing to console.
+++ // However, console might be redirected, so we make an attempt at
+++ // checking for that on platforms where we know how to do that.
+++ bool useColour = stream.isConsole();
+++#if defined( CATCH_INTERNAL_HAS_ISATTY ) && \
+++ !( defined( __DJGPP__ ) && defined( __STRICT_ANSI__ ) )
+++ ErrnoGuard _; // for isatty
+++ useColour = useColour && isatty( STDOUT_FILENO );
+++# endif
+++# if defined( CATCH_PLATFORM_MAC ) || defined( CATCH_PLATFORM_IPHONE )
+++ useColour = useColour && !isDebuggerActive();
+++# endif
+++
+++ return useColour;
+++ }
+++
+++ private:
+++ void use( Colour::Code _colourCode ) const override {
+++ auto setColour = [&out =
+++ m_stream->stream()]( char const* escapeCode ) {
+++ // The escape sequence must be flushed to console, otherwise
+++ // if stdin and stderr are intermixed, we'd get accidentally
+++ // coloured output.
+++ out << '\033' << escapeCode << std::flush;
+++ };
+++ switch( _colourCode ) {
+++ case Colour::None:
+++ case Colour::White: return setColour( "[0m" );
+++ case Colour::Red: return setColour( "[0;31m" );
+++ case Colour::Green: return setColour( "[0;32m" );
+++ case Colour::Blue: return setColour( "[0;34m" );
+++ case Colour::Cyan: return setColour( "[0;36m" );
+++ case Colour::Yellow: return setColour( "[0;33m" );
+++ case Colour::Grey: return setColour( "[1;30m" );
+++
+++ case Colour::LightGrey: return setColour( "[0;37m" );
+++ case Colour::BrightRed: return setColour( "[1;31m" );
+++ case Colour::BrightGreen: return setColour( "[1;32m" );
+++ case Colour::BrightWhite: return setColour( "[1;37m" );
+++ case Colour::BrightYellow: return setColour( "[1;33m" );
+++
+++ case Colour::Bright: CATCH_INTERNAL_ERROR( "not a colour" );
+++ default: CATCH_INTERNAL_ERROR( "Unknown colour requested" );
+++ }
+++ }
+++ };
+++
+++} // end anon namespace
+++} // end namespace Catch
+++
+++namespace Catch {
+++
+++ Detail::unique_ptr<ColourImpl> makeColourImpl( ColourMode colourSelection,
+++ IStream* stream ) {
+++#if defined( CATCH_CONFIG_COLOUR_WIN32 )
+++ if ( colourSelection == ColourMode::Win32 ) {
+++ return Detail::make_unique<Win32ColourImpl>( stream );
+++ }
+++#endif
+++ if ( colourSelection == ColourMode::ANSI ) {
+++ return Detail::make_unique<ANSIColourImpl>( stream );
+++ }
+++ if ( colourSelection == ColourMode::None ) {
+++ return Detail::make_unique<NoColourImpl>( stream );
+++ }
+++
+++ if ( colourSelection == ColourMode::PlatformDefault) {
+++#if defined( CATCH_CONFIG_COLOUR_WIN32 )
+++ if ( Win32ColourImpl::useImplementationForStream( *stream ) ) {
+++ return Detail::make_unique<Win32ColourImpl>( stream );
+++ }
+++#endif
+++ if ( ANSIColourImpl::useImplementationForStream( *stream ) ) {
+++ return Detail::make_unique<ANSIColourImpl>( stream );
+++ }
+++ return Detail::make_unique<NoColourImpl>( stream );
+++ }
+++
+++ CATCH_ERROR( "Could not create colour impl for selection " << static_cast<int>(colourSelection) );
+++ }
+++
+++ bool isColourImplAvailable( ColourMode colourSelection ) {
+++ switch ( colourSelection ) {
+++#if defined( CATCH_CONFIG_COLOUR_WIN32 )
+++ case ColourMode::Win32:
+++#endif
+++ case ColourMode::ANSI:
+++ case ColourMode::None:
+++ case ColourMode::PlatformDefault:
+++ return true;
+++ default:
+++ return false;
+++ }
+++ }
+++
+++
+++} // end namespace Catch
+++
+++#if defined(__clang__)
+++# pragma clang diagnostic pop
+++#endif
+++
+++
+++
+++
+++namespace Catch {
+++
+++ Context* Context::currentContext = nullptr;
+++
+++ void cleanUpContext() {
+++ delete Context::currentContext;
+++ Context::currentContext = nullptr;
+++ }
+++ void Context::createContext() {
+++ currentContext = new Context();
+++ }
+++
+++ Context& getCurrentMutableContext() {
+++ if ( !Context::currentContext ) { Context::createContext(); }
+++ // NOLINTNEXTLINE(clang-analyzer-core.uninitialized.UndefReturn)
+++ return *Context::currentContext;
+++ }
+++
+++ void Context::setResultCapture( IResultCapture* resultCapture ) {
+++ m_resultCapture = resultCapture;
+++ }
+++
+++ void Context::setConfig( IConfig const* config ) { m_config = config; }
+++
+++ SimplePcg32& sharedRng() {
+++ static SimplePcg32 s_rng;
+++ return s_rng;
+++ }
+++
+++}
+++
+++
+++
+++
+++
+++#include <ostream>
+++
+++#if defined(CATCH_CONFIG_ANDROID_LOGWRITE)
+++#include <android/log.h>
+++
+++ namespace Catch {
+++ void writeToDebugConsole( std::string const& text ) {
+++ __android_log_write( ANDROID_LOG_DEBUG, "Catch", text.c_str() );
+++ }
+++ }
+++
+++#elif defined(CATCH_PLATFORM_WINDOWS)
+++
+++ namespace Catch {
+++ void writeToDebugConsole( std::string const& text ) {
+++ ::OutputDebugStringA( text.c_str() );
+++ }
+++ }
+++
+++#else
+++
+++ namespace Catch {
+++ void writeToDebugConsole( std::string const& text ) {
+++ // !TBD: Need a version for Mac/ XCode and other IDEs
+++ Catch::cout() << text;
+++ }
+++ }
+++
+++#endif // Platform
+++
+++
+++
+++#if defined(CATCH_PLATFORM_MAC) || defined(CATCH_PLATFORM_IPHONE)
+++
+++# include <cassert>
+++# include <sys/types.h>
+++# include <unistd.h>
+++# include <cstddef>
+++# include <ostream>
+++
+++#ifdef __apple_build_version__
+++ // These headers will only compile with AppleClang (XCode)
+++ // For other compilers (Clang, GCC, ... ) we need to exclude them
+++# include <sys/sysctl.h>
+++#endif
+++
+++ namespace Catch {
+++ #ifdef __apple_build_version__
+++ // The following function is taken directly from the following technical note:
+++ // https://developer.apple.com/library/archive/qa/qa1361/_index.html
+++
+++ // Returns true if the current process is being debugged (either
+++ // running under the debugger or has a debugger attached post facto).
+++ bool isDebuggerActive(){
+++ int mib[4];
+++ struct kinfo_proc info;
+++ std::size_t size;
+++
+++ // Initialize the flags so that, if sysctl fails for some bizarre
+++ // reason, we get a predictable result.
+++
+++ info.kp_proc.p_flag = 0;
+++
+++ // Initialize mib, which tells sysctl the info we want, in this case
+++ // we're looking for information about a specific process ID.
+++
+++ mib[0] = CTL_KERN;
+++ mib[1] = KERN_PROC;
+++ mib[2] = KERN_PROC_PID;
+++ mib[3] = getpid();
+++
+++ // Call sysctl.
+++
+++ size = sizeof(info);
+++ if( sysctl(mib, sizeof(mib) / sizeof(*mib), &info, &size, nullptr, 0) != 0 ) {
+++ Catch::cerr() << "\n** Call to sysctl failed - unable to determine if debugger is active **\n\n" << std::flush;
+++ return false;
+++ }
+++
+++ // We're being debugged if the P_TRACED flag is set.
+++
+++ return ( (info.kp_proc.p_flag & P_TRACED) != 0 );
+++ }
+++ #else
+++ bool isDebuggerActive() {
+++ // We need to find another way to determine this for non-appleclang compilers on macOS
+++ return false;
+++ }
+++ #endif
+++ } // namespace Catch
+++
+++#elif defined(CATCH_PLATFORM_LINUX)
+++ #include <fstream>
+++ #include <string>
+++
+++ namespace Catch{
+++ // The standard POSIX way of detecting a debugger is to attempt to
+++ // ptrace() the process, but this needs to be done from a child and not
+++ // this process itself to still allow attaching to this process later
+++ // if wanted, so is rather heavy. Under Linux we have the PID of the
+++ // "debugger" (which doesn't need to be gdb, of course, it could also
+++ // be strace, for example) in /proc/$PID/status, so just get it from
+++ // there instead.
+++ bool isDebuggerActive(){
+++ // Libstdc++ has a bug, where std::ifstream sets errno to 0
+++ // This way our users can properly assert over errno values
+++ ErrnoGuard guard;
+++ std::ifstream in("/proc/self/status");
+++ for( std::string line; std::getline(in, line); ) {
+++ static const int PREFIX_LEN = 11;
+++ if( line.compare(0, PREFIX_LEN, "TracerPid:\t") == 0 ) {
+++ // We're traced if the PID is not 0 and no other PID starts
+++ // with 0 digit, so it's enough to check for just a single
+++ // character.
+++ return line.length() > PREFIX_LEN && line[PREFIX_LEN] != '0';
+++ }
+++ }
+++
+++ return false;
+++ }
+++ } // namespace Catch
+++#elif defined(_MSC_VER)
+++ extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+++ namespace Catch {
+++ bool isDebuggerActive() {
+++ return IsDebuggerPresent() != 0;
+++ }
+++ }
+++#elif defined(__MINGW32__)
+++ extern "C" __declspec(dllimport) int __stdcall IsDebuggerPresent();
+++ namespace Catch {
+++ bool isDebuggerActive() {
+++ return IsDebuggerPresent() != 0;
+++ }
+++ }
+++#else
+++ namespace Catch {
+++ bool isDebuggerActive() { return false; }
+++ }
+++#endif // Platform
+++
+++
+++
+++
+++namespace Catch {
+++
+++ void ITransientExpression::streamReconstructedExpression(
+++ std::ostream& os ) const {
+++ // We can't make this function pure virtual to keep ITransientExpression
+++ // constexpr, so we write error message instead
+++ os << "Some class derived from ITransientExpression without overriding streamReconstructedExpression";
+++ }
+++
+++ void formatReconstructedExpression( std::ostream &os, std::string const& lhs, StringRef op, std::string const& rhs ) {
+++ if( lhs.size() + rhs.size() < 40 &&
+++ lhs.find('\n') == std::string::npos &&
+++ rhs.find('\n') == std::string::npos )
+++ os << lhs << ' ' << op << ' ' << rhs;
+++ else
+++ os << lhs << '\n' << op << '\n' << rhs;
+++ }
+++}
+++
+++
+++
+++#include <stdexcept>
+++
+++
+++namespace Catch {
+++#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS) && !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS_CUSTOM_HANDLER)
+++ [[noreturn]]
+++ void throw_exception(std::exception const& e) {
+++ Catch::cerr() << "Catch will terminate because it needed to throw an exception.\n"
+++ << "The message was: " << e.what() << '\n';
+++ std::terminate();
+++ }
+++#endif
+++
+++ [[noreturn]]
+++ void throw_logic_error(std::string const& msg) {
+++ throw_exception(std::logic_error(msg));
+++ }
+++
+++ [[noreturn]]
+++ void throw_domain_error(std::string const& msg) {
+++ throw_exception(std::domain_error(msg));
+++ }
+++
+++ [[noreturn]]
+++ void throw_runtime_error(std::string const& msg) {
+++ throw_exception(std::runtime_error(msg));
+++ }
+++
+++
+++
+++} // namespace Catch;
+++
+++
+++
+++#include <cassert>
+++
+++namespace Catch {
+++
+++ IMutableEnumValuesRegistry::~IMutableEnumValuesRegistry() = default;
+++
+++ namespace Detail {
+++
+++ namespace {
+++ // Extracts the actual name part of an enum instance
+++ // In other words, it returns the Blue part of Bikeshed::Colour::Blue
+++ StringRef extractInstanceName(StringRef enumInstance) {
+++ // Find last occurrence of ":"
+++ size_t name_start = enumInstance.size();
+++ while (name_start > 0 && enumInstance[name_start - 1] != ':') {
+++ --name_start;
+++ }
+++ return enumInstance.substr(name_start, enumInstance.size() - name_start);
+++ }
+++ }
+++
+++ std::vector<StringRef> parseEnums( StringRef enums ) {
+++ auto enumValues = splitStringRef( enums, ',' );
+++ std::vector<StringRef> parsed;
+++ parsed.reserve( enumValues.size() );
+++ for( auto const& enumValue : enumValues ) {
+++ parsed.push_back(trim(extractInstanceName(enumValue)));
+++ }
+++ return parsed;
+++ }
+++
+++ EnumInfo::~EnumInfo() = default;
+++
+++ StringRef EnumInfo::lookup( int value ) const {
+++ for( auto const& valueToName : m_values ) {
+++ if( valueToName.first == value )
+++ return valueToName.second;
+++ }
+++ return "{** unexpected enum value **}"_sr;
+++ }
+++
+++ Catch::Detail::unique_ptr<EnumInfo> makeEnumInfo( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+++ auto enumInfo = Catch::Detail::make_unique<EnumInfo>();
+++ enumInfo->m_name = enumName;
+++ enumInfo->m_values.reserve( values.size() );
+++
+++ const auto valueNames = Catch::Detail::parseEnums( allValueNames );
+++ assert( valueNames.size() == values.size() );
+++ std::size_t i = 0;
+++ for( auto value : values )
+++ enumInfo->m_values.emplace_back(value, valueNames[i++]);
+++
+++ return enumInfo;
+++ }
+++
+++ EnumInfo const& EnumValuesRegistry::registerEnum( StringRef enumName, StringRef allValueNames, std::vector<int> const& values ) {
+++ m_enumInfos.push_back(makeEnumInfo(enumName, allValueNames, values));
+++ return *m_enumInfos.back();
+++ }
+++
+++ } // Detail
+++} // Catch
+++
+++
+++
+++
+++
+++#include <cerrno>
+++
+++namespace Catch {
+++ ErrnoGuard::ErrnoGuard():m_oldErrno(errno){}
+++ ErrnoGuard::~ErrnoGuard() { errno = m_oldErrno; }
+++}
+++
+++
+++
+++#include <exception>
+++
+++namespace Catch {
+++
+++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+++ namespace {
+++ static std::string tryTranslators(
+++ std::vector<
+++ Detail::unique_ptr<IExceptionTranslator const>> const& translators ) {
+++ if ( translators.empty() ) {
+++ std::rethrow_exception( std::current_exception() );
+++ } else {
+++ return translators[0]->translate( translators.begin() + 1,
+++ translators.end() );
+++ }
+++ }
+++
+++ }
+++#endif //!defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+++
+++ ExceptionTranslatorRegistry::~ExceptionTranslatorRegistry() = default;
+++
+++ void ExceptionTranslatorRegistry::registerTranslator( Detail::unique_ptr<IExceptionTranslator>&& translator ) {
+++ m_translators.push_back( CATCH_MOVE( translator ) );
+++ }
+++
+++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+++ std::string ExceptionTranslatorRegistry::translateActiveException() const {
+++ // Compiling a mixed mode project with MSVC means that CLR
+++ // exceptions will be caught in (...) as well. However, these do
+++ // do not fill-in std::current_exception and thus lead to crash
+++ // when attempting rethrow.
+++ // /EHa switch also causes structured exceptions to be caught
+++ // here, but they fill-in current_exception properly, so
+++ // at worst the output should be a little weird, instead of
+++ // causing a crash.
+++ if ( std::current_exception() == nullptr ) {
+++ return "Non C++ exception. Possibly a CLR exception.";
+++ }
+++
+++ // First we try user-registered translators. If none of them can
+++ // handle the exception, it will be rethrown handled by our defaults.
+++ try {
+++ return tryTranslators(m_translators);
+++ }
+++ // To avoid having to handle TFE explicitly everywhere, we just
+++ // rethrow it so that it goes back up the caller.
+++ catch( TestFailureException& ) {
+++ std::rethrow_exception(std::current_exception());
+++ }
+++ catch( TestSkipException& ) {
+++ std::rethrow_exception(std::current_exception());
+++ }
+++ catch( std::exception const& ex ) {
+++ return ex.what();
+++ }
+++ catch( std::string const& msg ) {
+++ return msg;
+++ }
+++ catch( const char* msg ) {
+++ return msg;
+++ }
+++ catch(...) {
+++ return "Unknown exception";
+++ }
+++ }
+++
+++#else // ^^ Exceptions are enabled // Exceptions are disabled vv
+++ std::string ExceptionTranslatorRegistry::translateActiveException() const {
+++ CATCH_INTERNAL_ERROR("Attempted to translate active exception under CATCH_CONFIG_DISABLE_EXCEPTIONS!");
+++ }
+++#endif
+++
+++}
+++
+++
+++
+++/** \file
+++ * This file provides platform specific implementations of FatalConditionHandler
+++ *
+++ * This means that there is a lot of conditional compilation, and platform
+++ * specific code. Currently, Catch2 supports a dummy handler (if no
+++ * handler is desired), and 2 platform specific handlers:
+++ * * Windows' SEH
+++ * * POSIX signals
+++ *
+++ * Consequently, various pieces of code below are compiled if either of
+++ * the platform specific handlers is enabled, or if none of them are
+++ * enabled. It is assumed that both cannot be enabled at the same time,
+++ * and doing so should cause a compilation error.
+++ *
+++ * If another platform specific handler is added, the compile guards
+++ * below will need to be updated taking these assumptions into account.
+++ */
+++
+++
+++
+++#include <algorithm>
+++
+++#if !defined( CATCH_CONFIG_WINDOWS_SEH ) && !defined( CATCH_CONFIG_POSIX_SIGNALS )
+++
+++namespace Catch {
+++
+++ // If neither SEH nor signal handling is required, the handler impls
+++ // do not have to do anything, and can be empty.
+++ void FatalConditionHandler::engage_platform() {}
+++ void FatalConditionHandler::disengage_platform() noexcept {}
+++ FatalConditionHandler::FatalConditionHandler() = default;
+++ FatalConditionHandler::~FatalConditionHandler() = default;
+++
+++} // end namespace Catch
+++
+++#endif // !CATCH_CONFIG_WINDOWS_SEH && !CATCH_CONFIG_POSIX_SIGNALS
+++
+++#if defined( CATCH_CONFIG_WINDOWS_SEH ) && defined( CATCH_CONFIG_POSIX_SIGNALS )
+++#error "Inconsistent configuration: Windows' SEH handling and POSIX signals cannot be enabled at the same time"
+++#endif // CATCH_CONFIG_WINDOWS_SEH && CATCH_CONFIG_POSIX_SIGNALS
+++
+++#if defined( CATCH_CONFIG_WINDOWS_SEH ) || defined( CATCH_CONFIG_POSIX_SIGNALS )
+++
+++namespace {
+++ //! Signals fatal error message to the run context
+++ void reportFatal( char const * const message ) {
+++ Catch::getCurrentContext().getResultCapture()->handleFatalErrorCondition( message );
+++ }
+++
+++ //! Minimal size Catch2 needs for its own fatal error handling.
+++ //! Picked empirically, so it might not be sufficient on all
+++ //! platforms, and for all configurations.
+++ constexpr std::size_t minStackSizeForErrors = 32 * 1024;
+++} // end unnamed namespace
+++
+++#endif // CATCH_CONFIG_WINDOWS_SEH || CATCH_CONFIG_POSIX_SIGNALS
+++
+++#if defined( CATCH_CONFIG_WINDOWS_SEH )
+++
+++namespace Catch {
+++
+++ struct SignalDefs { DWORD id; const char* name; };
+++
+++ // There is no 1-1 mapping between signals and windows exceptions.
+++ // Windows can easily distinguish between SO and SigSegV,
+++ // but SigInt, SigTerm, etc are handled differently.
+++ static SignalDefs signalDefs[] = {
+++ { EXCEPTION_ILLEGAL_INSTRUCTION, "SIGILL - Illegal instruction signal" },
+++ { EXCEPTION_STACK_OVERFLOW, "SIGSEGV - Stack overflow" },
+++ { EXCEPTION_ACCESS_VIOLATION, "SIGSEGV - Segmentation violation signal" },
+++ { EXCEPTION_INT_DIVIDE_BY_ZERO, "Divide by zero error" },
+++ };
+++
+++ static LONG CALLBACK topLevelExceptionFilter(PEXCEPTION_POINTERS ExceptionInfo) {
+++ for (auto const& def : signalDefs) {
+++ if (ExceptionInfo->ExceptionRecord->ExceptionCode == def.id) {
+++ reportFatal(def.name);
+++ }
+++ }
+++ // If its not an exception we care about, pass it along.
+++ // This stops us from eating debugger breaks etc.
+++ return EXCEPTION_CONTINUE_SEARCH;
+++ }
+++
+++ // Since we do not support multiple instantiations, we put these
+++ // into global variables and rely on cleaning them up in outlined
+++ // constructors/destructors
+++ static LPTOP_LEVEL_EXCEPTION_FILTER previousTopLevelExceptionFilter = nullptr;
+++
+++
+++ // For MSVC, we reserve part of the stack memory for handling
+++ // memory overflow structured exception.
+++ FatalConditionHandler::FatalConditionHandler() {
+++ ULONG guaranteeSize = static_cast<ULONG>(minStackSizeForErrors);
+++ if (!SetThreadStackGuarantee(&guaranteeSize)) {
+++ // We do not want to fully error out, because needing
+++ // the stack reserve should be rare enough anyway.
+++ Catch::cerr()
+++ << "Failed to reserve piece of stack."
+++ << " Stack overflows will not be reported successfully.";
+++ }
+++ }
+++
+++ // We do not attempt to unset the stack guarantee, because
+++ // Windows does not support lowering the stack size guarantee.
+++ FatalConditionHandler::~FatalConditionHandler() = default;
+++
+++
+++ void FatalConditionHandler::engage_platform() {
+++ // Register as a the top level exception filter.
+++ previousTopLevelExceptionFilter = SetUnhandledExceptionFilter(topLevelExceptionFilter);
+++ }
+++
+++ void FatalConditionHandler::disengage_platform() noexcept {
+++ if (SetUnhandledExceptionFilter(previousTopLevelExceptionFilter) != topLevelExceptionFilter) {
+++ Catch::cerr()
+++ << "Unexpected SEH unhandled exception filter on disengage."
+++ << " The filter was restored, but might be rolled back unexpectedly.";
+++ }
+++ previousTopLevelExceptionFilter = nullptr;
+++ }
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_CONFIG_WINDOWS_SEH
+++
+++#if defined( CATCH_CONFIG_POSIX_SIGNALS )
+++
+++#include <signal.h>
+++
+++namespace Catch {
+++
+++ struct SignalDefs {
+++ int id;
+++ const char* name;
+++ };
+++
+++ static SignalDefs signalDefs[] = {
+++ { SIGINT, "SIGINT - Terminal interrupt signal" },
+++ { SIGILL, "SIGILL - Illegal instruction signal" },
+++ { SIGFPE, "SIGFPE - Floating point error signal" },
+++ { SIGSEGV, "SIGSEGV - Segmentation violation signal" },
+++ { SIGTERM, "SIGTERM - Termination request signal" },
+++ { SIGABRT, "SIGABRT - Abort (abnormal termination) signal" }
+++ };
+++
+++// Older GCCs trigger -Wmissing-field-initializers for T foo = {}
+++// which is zero initialization, but not explicit. We want to avoid
+++// that.
+++#if defined(__GNUC__)
+++# pragma GCC diagnostic push
+++# pragma GCC diagnostic ignored "-Wmissing-field-initializers"
+++#endif
+++
+++ static char* altStackMem = nullptr;
+++ static std::size_t altStackSize = 0;
+++ static stack_t oldSigStack{};
+++ static struct sigaction oldSigActions[sizeof(signalDefs) / sizeof(SignalDefs)]{};
+++
+++ static void restorePreviousSignalHandlers() noexcept {
+++ // We set signal handlers back to the previous ones. Hopefully
+++ // nobody overwrote them in the meantime, and doesn't expect
+++ // their signal handlers to live past ours given that they
+++ // installed them after ours..
+++ for (std::size_t i = 0; i < sizeof(signalDefs) / sizeof(SignalDefs); ++i) {
+++ sigaction(signalDefs[i].id, &oldSigActions[i], nullptr);
+++ }
+++ // Return the old stack
+++ sigaltstack(&oldSigStack, nullptr);
+++ }
+++
+++ static void handleSignal( int sig ) {
+++ char const * name = "<unknown signal>";
+++ for (auto const& def : signalDefs) {
+++ if (sig == def.id) {
+++ name = def.name;
+++ break;
+++ }
+++ }
+++ // We need to restore previous signal handlers and let them do
+++ // their thing, so that the users can have the debugger break
+++ // when a signal is raised, and so on.
+++ restorePreviousSignalHandlers();
+++ reportFatal( name );
+++ raise( sig );
+++ }
+++
+++ FatalConditionHandler::FatalConditionHandler() {
+++ assert(!altStackMem && "Cannot initialize POSIX signal handler when one already exists");
+++ if (altStackSize == 0) {
+++ altStackSize = std::max(static_cast<size_t>(SIGSTKSZ), minStackSizeForErrors);
+++ }
+++ altStackMem = new char[altStackSize]();
+++ }
+++
+++ FatalConditionHandler::~FatalConditionHandler() {
+++ delete[] altStackMem;
+++ // We signal that another instance can be constructed by zeroing
+++ // out the pointer.
+++ altStackMem = nullptr;
+++ }
+++
+++ void FatalConditionHandler::engage_platform() {
+++ stack_t sigStack;
+++ sigStack.ss_sp = altStackMem;
+++ sigStack.ss_size = altStackSize;
+++ sigStack.ss_flags = 0;
+++ sigaltstack(&sigStack, &oldSigStack);
+++ struct sigaction sa = { };
+++
+++ sa.sa_handler = handleSignal;
+++ sa.sa_flags = SA_ONSTACK;
+++ for (std::size_t i = 0; i < sizeof(signalDefs)/sizeof(SignalDefs); ++i) {
+++ sigaction(signalDefs[i].id, &sa, &oldSigActions[i]);
+++ }
+++ }
+++
+++#if defined(__GNUC__)
+++# pragma GCC diagnostic pop
+++#endif
+++
+++
+++ void FatalConditionHandler::disengage_platform() noexcept {
+++ restorePreviousSignalHandlers();
+++ }
+++
+++} // end namespace Catch
+++
+++#endif // CATCH_CONFIG_POSIX_SIGNALS
+++
+++
+++
+++
+++#include <cstring>
+++
+++namespace Catch {
+++ namespace Detail {
+++
+++ uint32_t convertToBits(float f) {
+++ static_assert(sizeof(float) == sizeof(uint32_t), "Important ULP matcher assumption violated");
+++ uint32_t i;
+++ std::memcpy(&i, &f, sizeof(f));
+++ return i;
+++ }
+++
+++ uint64_t convertToBits(double d) {
+++ static_assert(sizeof(double) == sizeof(uint64_t), "Important ULP matcher assumption violated");
+++ uint64_t i;
+++ std::memcpy(&i, &d, sizeof(d));
+++ return i;
+++ }
+++
+++#if defined( __GNUC__ ) || defined( __clang__ )
+++# pragma GCC diagnostic push
+++# pragma GCC diagnostic ignored "-Wfloat-equal"
+++#endif
+++ bool directCompare( float lhs, float rhs ) { return lhs == rhs; }
+++ bool directCompare( double lhs, double rhs ) { return lhs == rhs; }
+++#if defined( __GNUC__ ) || defined( __clang__ )
+++# pragma GCC diagnostic pop
+++#endif
+++
+++
+++ } // end namespace Detail
+++} // end namespace Catch
+++
+++
+++
+++
+++
+++
+++#include <cstdlib>
+++
+++namespace Catch {
+++ namespace Detail {
+++
+++#if !defined (CATCH_CONFIG_GETENV)
+++ char const* getEnv( char const* ) { return nullptr; }
+++#else
+++
+++ char const* getEnv( char const* varName ) {
+++# if defined( _MSC_VER )
+++# pragma warning( push )
+++# pragma warning( disable : 4996 ) // use getenv_s instead of getenv
+++# endif
+++
+++ return std::getenv( varName );
+++
+++# if defined( _MSC_VER )
+++# pragma warning( pop )
+++# endif
+++ }
+++#endif
+++} // namespace Detail
+++} // namespace Catch
+++
+++
+++
+++
+++#include <cstdio>
+++#include <fstream>
+++#include <sstream>
+++#include <vector>
+++
+++namespace Catch {
+++
+++ Catch::IStream::~IStream() = default;
+++
+++namespace Detail {
+++ namespace {
+++ template<typename WriterF, std::size_t bufferSize=256>
+++ class StreamBufImpl final : public std::streambuf {
+++ char data[bufferSize];
+++ WriterF m_writer;
+++
+++ public:
+++ StreamBufImpl() {
+++ setp( data, data + sizeof(data) );
+++ }
+++
+++ ~StreamBufImpl() noexcept override {
+++ StreamBufImpl::sync();
+++ }
+++
+++ private:
+++ int overflow( int c ) override {
+++ sync();
+++
+++ if( c != EOF ) {
+++ if( pbase() == epptr() )
+++ m_writer( std::string( 1, static_cast<char>( c ) ) );
+++ else
+++ sputc( static_cast<char>( c ) );
+++ }
+++ return 0;
+++ }
+++
+++ int sync() override {
+++ if( pbase() != pptr() ) {
+++ m_writer( std::string( pbase(), static_cast<std::string::size_type>( pptr() - pbase() ) ) );
+++ setp( pbase(), epptr() );
+++ }
+++ return 0;
+++ }
+++ };
+++
+++ ///////////////////////////////////////////////////////////////////////////
+++
+++ struct OutputDebugWriter {
+++
+++ void operator()( std::string const& str ) {
+++ if ( !str.empty() ) {
+++ writeToDebugConsole( str );
+++ }
+++ }
+++ };
+++
+++ ///////////////////////////////////////////////////////////////////////////
+++
+++ class FileStream final : public IStream {
+++ std::ofstream m_ofs;
+++ public:
+++ FileStream( std::string const& filename ) {
+++ m_ofs.open( filename.c_str() );
+++ CATCH_ENFORCE( !m_ofs.fail(), "Unable to open file: '" << filename << '\'' );
+++ m_ofs << std::unitbuf;
+++ }
+++ public: // IStream
+++ std::ostream& stream() override {
+++ return m_ofs;
+++ }
+++ };
+++
+++ ///////////////////////////////////////////////////////////////////////////
+++
+++ class CoutStream final : public IStream {
+++ std::ostream m_os;
+++ public:
+++ // Store the streambuf from cout up-front because
+++ // cout may get redirected when running tests
+++ CoutStream() : m_os( Catch::cout().rdbuf() ) {}
+++
+++ public: // IStream
+++ std::ostream& stream() override { return m_os; }
+++ bool isConsole() const override { return true; }
+++ };
+++
+++ class CerrStream : public IStream {
+++ std::ostream m_os;
+++
+++ public:
+++ // Store the streambuf from cerr up-front because
+++ // cout may get redirected when running tests
+++ CerrStream(): m_os( Catch::cerr().rdbuf() ) {}
+++
+++ public: // IStream
+++ std::ostream& stream() override { return m_os; }
+++ bool isConsole() const override { return true; }
+++ };
+++
+++ ///////////////////////////////////////////////////////////////////////////
+++
+++ class DebugOutStream final : public IStream {
+++ Detail::unique_ptr<StreamBufImpl<OutputDebugWriter>> m_streamBuf;
+++ std::ostream m_os;
+++ public:
+++ DebugOutStream()
+++ : m_streamBuf( Detail::make_unique<StreamBufImpl<OutputDebugWriter>>() ),
+++ m_os( m_streamBuf.get() )
+++ {}
+++
+++ public: // IStream
+++ std::ostream& stream() override { return m_os; }
+++ };
+++
+++ } // unnamed namespace
+++} // namespace Detail
+++
+++ ///////////////////////////////////////////////////////////////////////////
+++
+++ auto makeStream( std::string const& filename ) -> Detail::unique_ptr<IStream> {
+++ if ( filename.empty() || filename == "-" ) {
+++ return Detail::make_unique<Detail::CoutStream>();
+++ }
+++ if( filename[0] == '%' ) {
+++ if ( filename == "%debug" ) {
+++ return Detail::make_unique<Detail::DebugOutStream>();
+++ } else if ( filename == "%stderr" ) {
+++ return Detail::make_unique<Detail::CerrStream>();
+++ } else if ( filename == "%stdout" ) {
+++ return Detail::make_unique<Detail::CoutStream>();
+++ } else {
+++ CATCH_ERROR( "Unrecognised stream: '" << filename << '\'' );
+++ }
+++ }
+++ return Detail::make_unique<Detail::FileStream>( filename );
+++ }
+++
+++}
+++
+++
+++
+++namespace Catch {
+++ void JsonUtils::indent( std::ostream& os, std::uint64_t level ) {
+++ for ( std::uint64_t i = 0; i < level; ++i ) {
+++ os << " ";
+++ }
+++ }
+++ void JsonUtils::appendCommaNewline( std::ostream& os,
+++ bool& should_comma,
+++ std::uint64_t level ) {
+++ if ( should_comma ) { os << ','; }
+++ should_comma = true;
+++ os << '\n';
+++ indent( os, level );
+++ }
+++
+++ JsonObjectWriter::JsonObjectWriter( std::ostream& os ):
+++ JsonObjectWriter{ os, 0 } {}
+++
+++ JsonObjectWriter::JsonObjectWriter( std::ostream& os,
+++ std::uint64_t indent_level ):
+++ m_os{ os }, m_indent_level{ indent_level } {
+++ m_os << '{';
+++ }
+++ JsonObjectWriter::JsonObjectWriter( JsonObjectWriter&& source ) noexcept:
+++ m_os{ source.m_os },
+++ m_indent_level{ source.m_indent_level },
+++ m_should_comma{ source.m_should_comma },
+++ m_active{ source.m_active } {
+++ source.m_active = false;
+++ }
+++
+++ JsonObjectWriter::~JsonObjectWriter() {
+++ if ( !m_active ) { return; }
+++
+++ m_os << '\n';
+++ JsonUtils::indent( m_os, m_indent_level );
+++ m_os << '}';
+++ }
+++
+++ JsonValueWriter JsonObjectWriter::write( StringRef key ) {
+++ JsonUtils::appendCommaNewline(
+++ m_os, m_should_comma, m_indent_level + 1 );
+++
+++ m_os << '"' << key << "\": ";
+++ return JsonValueWriter{ m_os, m_indent_level + 1 };
+++ }
+++
+++ JsonArrayWriter::JsonArrayWriter( std::ostream& os ):
+++ JsonArrayWriter{ os, 0 } {}
+++ JsonArrayWriter::JsonArrayWriter( std::ostream& os,
+++ std::uint64_t indent_level ):
+++ m_os{ os }, m_indent_level{ indent_level } {
+++ m_os << '[';
+++ }
+++ JsonArrayWriter::JsonArrayWriter( JsonArrayWriter&& source ) noexcept:
+++ m_os{ source.m_os },
+++ m_indent_level{ source.m_indent_level },
+++ m_should_comma{ source.m_should_comma },
+++ m_active{ source.m_active } {
+++ source.m_active = false;
+++ }
+++ JsonArrayWriter::~JsonArrayWriter() {
+++ if ( !m_active ) { return; }
+++
+++ m_os << '\n';
+++ JsonUtils::indent( m_os, m_indent_level );
+++ m_os << ']';
+++ }
+++
+++ JsonObjectWriter JsonArrayWriter::writeObject() {
+++ JsonUtils::appendCommaNewline(
+++ m_os, m_should_comma, m_indent_level + 1 );
+++ return JsonObjectWriter{ m_os, m_indent_level + 1 };
+++ }
+++
+++ JsonArrayWriter JsonArrayWriter::writeArray() {
+++ JsonUtils::appendCommaNewline(
+++ m_os, m_should_comma, m_indent_level + 1 );
+++ return JsonArrayWriter{ m_os, m_indent_level + 1 };
+++ }
+++
+++ JsonArrayWriter& JsonArrayWriter::write( bool value ) {
+++ return writeImpl( value );
+++ }
+++
+++ JsonValueWriter::JsonValueWriter( std::ostream& os ):
+++ JsonValueWriter{ os, 0 } {}
+++
+++ JsonValueWriter::JsonValueWriter( std::ostream& os,
+++ std::uint64_t indent_level ):
+++ m_os{ os }, m_indent_level{ indent_level } {}
+++
+++ JsonObjectWriter JsonValueWriter::writeObject() && {
+++ return JsonObjectWriter{ m_os, m_indent_level };
+++ }
+++
+++ JsonArrayWriter JsonValueWriter::writeArray() && {
+++ return JsonArrayWriter{ m_os, m_indent_level };
+++ }
+++
+++ void JsonValueWriter::write( Catch::StringRef value ) && {
+++ writeImpl( value, true );
+++ }
+++
+++ void JsonValueWriter::write( bool value ) && {
+++ writeImpl( value ? "true"_sr : "false"_sr, false );
+++ }
+++
+++ void JsonValueWriter::writeImpl( Catch::StringRef value, bool quote ) {
+++ if ( quote ) { m_os << '"'; }
+++ for (char c : value) {
+++ // Escape list taken from https://www.json.org/json-en.html,
+++ // string definition.
+++ // Note that while forward slash _can_ be escaped, it does
+++ // not have to be, if JSON is not further embedded somewhere
+++ // where forward slash is meaningful.
+++ if ( c == '"' ) {
+++ m_os << "\\\"";
+++ } else if ( c == '\\' ) {
+++ m_os << "\\\\";
+++ } else if ( c == '\b' ) {
+++ m_os << "\\b";
+++ } else if ( c == '\f' ) {
+++ m_os << "\\f";
+++ } else if ( c == '\n' ) {
+++ m_os << "\\n";
+++ } else if ( c == '\r' ) {
+++ m_os << "\\r";
+++ } else if ( c == '\t' ) {
+++ m_os << "\\t";
+++ } else {
+++ m_os << c;
+++ }
+++ }
+++ if ( quote ) { m_os << '"'; }
+++ }
+++
+++} // namespace Catch
+++
+++
+++
+++
+++namespace Catch {
+++
+++ auto operator << (std::ostream& os, LazyExpression const& lazyExpr) -> std::ostream& {
+++ if (lazyExpr.m_isNegated)
+++ os << '!';
+++
+++ if (lazyExpr) {
+++ if (lazyExpr.m_isNegated && lazyExpr.m_transientExpression->isBinaryExpression())
+++ os << '(' << *lazyExpr.m_transientExpression << ')';
+++ else
+++ os << *lazyExpr.m_transientExpression;
+++ } else {
+++ os << "{** error - unchecked empty expression requested **}";
+++ }
+++ return os;
+++ }
+++
+++} // namespace Catch
+++
+++
+++
+++
+++#ifdef CATCH_CONFIG_WINDOWS_CRTDBG
+++#include <crtdbg.h>
+++
+++namespace Catch {
+++
+++ LeakDetector::LeakDetector() {
+++ int flag = _CrtSetDbgFlag(_CRTDBG_REPORT_FLAG);
+++ flag |= _CRTDBG_LEAK_CHECK_DF;
+++ flag |= _CRTDBG_ALLOC_MEM_DF;
+++ _CrtSetDbgFlag(flag);
+++ _CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE | _CRTDBG_MODE_DEBUG);
+++ _CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
+++ // Change this to leaking allocation's number to break there
+++ _CrtSetBreakAlloc(-1);
+++ }
+++}
+++
+++#else // ^^ Windows crt debug heap enabled // Windows crt debug heap disabled vv
+++
+++ Catch::LeakDetector::LeakDetector() = default;
+++
+++#endif // CATCH_CONFIG_WINDOWS_CRTDBG
+++
+++Catch::LeakDetector::~LeakDetector() {
+++ Catch::cleanUp();
+++}
+++
+++
+++
+++
+++namespace Catch {
+++ namespace {
+++
+++ void listTests(IEventListener& reporter, IConfig const& config) {
+++ auto const& testSpec = config.testSpec();
+++ auto matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
+++ reporter.listTests(matchedTestCases);
+++ }
+++
+++ void listTags(IEventListener& reporter, IConfig const& config) {
+++ auto const& testSpec = config.testSpec();
+++ std::vector<TestCaseHandle> matchedTestCases = filterTests(getAllTestCasesSorted(config), testSpec, config);
+++
+++ std::map<StringRef, TagInfo, Detail::CaseInsensitiveLess> tagCounts;
+++ for (auto const& testCase : matchedTestCases) {
+++ for (auto const& tagName : testCase.getTestCaseInfo().tags) {
+++ auto it = tagCounts.find(tagName.original);
+++ if (it == tagCounts.end())
+++ it = tagCounts.insert(std::make_pair(tagName.original, TagInfo())).first;
+++ it->second.add(tagName.original);
+++ }
+++ }
+++
+++ std::vector<TagInfo> infos; infos.reserve(tagCounts.size());
+++ for (auto& tagc : tagCounts) {
+++ infos.push_back(CATCH_MOVE(tagc.second));
+++ }
+++
+++ reporter.listTags(infos);
+++ }
+++
+++ void listReporters(IEventListener& reporter) {
+++ std::vector<ReporterDescription> descriptions;
+++
+++ auto const& factories = getRegistryHub().getReporterRegistry().getFactories();
+++ descriptions.reserve(factories.size());
+++ for (auto const& fac : factories) {
+++ descriptions.push_back({ fac.first, fac.second->getDescription() });
+++ }
+++
+++ reporter.listReporters(descriptions);
+++ }
+++
+++ void listListeners(IEventListener& reporter) {
+++ std::vector<ListenerDescription> descriptions;
+++
+++ auto const& factories =
+++ getRegistryHub().getReporterRegistry().getListeners();
+++ descriptions.reserve( factories.size() );
+++ for ( auto const& fac : factories ) {
+++ descriptions.push_back( { fac->getName(), fac->getDescription() } );
+++ }
+++
+++ reporter.listListeners( descriptions );
+++ }
+++
+++ } // end anonymous namespace
+++
+++ void TagInfo::add( StringRef spelling ) {
+++ ++count;
+++ spellings.insert( spelling );
+++ }
+++
+++ std::string TagInfo::all() const {
+++ // 2 per tag for brackets '[' and ']'
+++ size_t size = spellings.size() * 2;
+++ for (auto const& spelling : spellings) {
+++ size += spelling.size();
+++ }
+++
+++ std::string out; out.reserve(size);
+++ for (auto const& spelling : spellings) {
+++ out += '[';
+++ out += spelling;
+++ out += ']';
+++ }
+++ return out;
+++ }
+++
+++ bool list( IEventListener& reporter, Config const& config ) {
+++ bool listed = false;
+++ if (config.listTests()) {
+++ listed = true;
+++ listTests(reporter, config);
+++ }
+++ if (config.listTags()) {
+++ listed = true;
+++ listTags(reporter, config);
+++ }
+++ if (config.listReporters()) {
+++ listed = true;
+++ listReporters(reporter);
+++ }
+++ if ( config.listListeners() ) {
+++ listed = true;
+++ listListeners( reporter );
+++ }
+++ return listed;
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++namespace Catch {
+++ CATCH_INTERNAL_START_WARNINGS_SUPPRESSION
+++ CATCH_INTERNAL_SUPPRESS_GLOBALS_WARNINGS
+++ static LeakDetector leakDetector;
+++ CATCH_INTERNAL_STOP_WARNINGS_SUPPRESSION
+++}
+++
+++// Allow users of amalgamated .cpp file to remove our main and provide their own.
+++#if !defined(CATCH_AMALGAMATED_CUSTOM_MAIN)
+++
+++#if defined(CATCH_CONFIG_WCHAR) && defined(CATCH_PLATFORM_WINDOWS) && defined(_UNICODE) && !defined(DO_NOT_USE_WMAIN)
+++// Standard C/C++ Win32 Unicode wmain entry point
+++extern "C" int __cdecl wmain (int argc, wchar_t * argv[], wchar_t * []) {
+++#else
+++// Standard C/C++ main entry point
+++int main (int argc, char * argv[]) {
+++#endif
+++
+++ // We want to force the linker not to discard the global variable
+++ // and its constructor, as it (optionally) registers leak detector
+++ (void)&Catch::leakDetector;
+++
+++ return Catch::Session().run( argc, argv );
+++}
+++
+++#endif // !defined(CATCH_AMALGAMATED_CUSTOM_MAIN
+++
+++
+++
+++
+++namespace Catch {
+++
+++ MessageInfo::MessageInfo( StringRef _macroName,
+++ SourceLineInfo const& _lineInfo,
+++ ResultWas::OfType _type )
+++ : macroName( _macroName ),
+++ lineInfo( _lineInfo ),
+++ type( _type ),
+++ sequence( ++globalCount )
+++ {}
+++
+++ // This may need protecting if threading support is added
+++ unsigned int MessageInfo::globalCount = 0;
+++
+++} // end namespace Catch
+++
+++
+++
+++#include <cstdio>
+++#include <cstring>
+++#include <sstream>
+++
+++#if defined(CATCH_CONFIG_NEW_CAPTURE)
+++ #if defined(_MSC_VER)
+++ #include <io.h> //_dup and _dup2
+++ #define dup _dup
+++ #define dup2 _dup2
+++ #define fileno _fileno
+++ #else
+++ #include <unistd.h> // dup and dup2
+++ #endif
+++#endif
+++
+++
+++namespace Catch {
+++
+++ RedirectedStream::RedirectedStream( std::ostream& originalStream, std::ostream& redirectionStream )
+++ : m_originalStream( originalStream ),
+++ m_redirectionStream( redirectionStream ),
+++ m_prevBuf( m_originalStream.rdbuf() )
+++ {
+++ m_originalStream.rdbuf( m_redirectionStream.rdbuf() );
+++ }
+++
+++ RedirectedStream::~RedirectedStream() {
+++ m_originalStream.rdbuf( m_prevBuf );
+++ }
+++
+++ RedirectedStdOut::RedirectedStdOut() : m_cout( Catch::cout(), m_rss.get() ) {}
+++ auto RedirectedStdOut::str() const -> std::string { return m_rss.str(); }
+++
+++ RedirectedStdErr::RedirectedStdErr()
+++ : m_cerr( Catch::cerr(), m_rss.get() ),
+++ m_clog( Catch::clog(), m_rss.get() )
+++ {}
+++ auto RedirectedStdErr::str() const -> std::string { return m_rss.str(); }
+++
+++ RedirectedStreams::RedirectedStreams(std::string& redirectedCout, std::string& redirectedCerr)
+++ : m_redirectedCout(redirectedCout),
+++ m_redirectedCerr(redirectedCerr)
+++ {}
+++
+++ RedirectedStreams::~RedirectedStreams() {
+++ m_redirectedCout += m_redirectedStdOut.str();
+++ m_redirectedCerr += m_redirectedStdErr.str();
+++ }
+++
+++#if defined(CATCH_CONFIG_NEW_CAPTURE)
+++
+++#if defined(_MSC_VER)
+++ TempFile::TempFile() {
+++ if (tmpnam_s(m_buffer)) {
+++ CATCH_RUNTIME_ERROR("Could not get a temp filename");
+++ }
+++ if (fopen_s(&m_file, m_buffer, "w+")) {
+++ char buffer[100];
+++ if (strerror_s(buffer, errno)) {
+++ CATCH_RUNTIME_ERROR("Could not translate errno to a string");
+++ }
+++ CATCH_RUNTIME_ERROR("Could not open the temp file: '" << m_buffer << "' because: " << buffer);
+++ }
+++ }
+++#else
+++ TempFile::TempFile() {
+++ m_file = std::tmpfile();
+++ if (!m_file) {
+++ CATCH_RUNTIME_ERROR("Could not create a temp file.");
+++ }
+++ }
+++
+++#endif
+++
+++ TempFile::~TempFile() {
+++ // TBD: What to do about errors here?
+++ std::fclose(m_file);
+++ // We manually create the file on Windows only, on Linux
+++ // it will be autodeleted
+++#if defined(_MSC_VER)
+++ std::remove(m_buffer);
+++#endif
+++ }
+++
+++
+++ FILE* TempFile::getFile() {
+++ return m_file;
+++ }
+++
+++ std::string TempFile::getContents() {
+++ std::stringstream sstr;
+++ char buffer[100] = {};
+++ std::rewind(m_file);
+++ while (std::fgets(buffer, sizeof(buffer), m_file)) {
+++ sstr << buffer;
+++ }
+++ return sstr.str();
+++ }
+++
+++ OutputRedirect::OutputRedirect(std::string& stdout_dest, std::string& stderr_dest) :
+++ m_originalStdout(dup(1)),
+++ m_originalStderr(dup(2)),
+++ m_stdoutDest(stdout_dest),
+++ m_stderrDest(stderr_dest) {
+++ dup2(fileno(m_stdoutFile.getFile()), 1);
+++ dup2(fileno(m_stderrFile.getFile()), 2);
+++ }
+++
+++ OutputRedirect::~OutputRedirect() {
+++ Catch::cout() << std::flush;
+++ fflush(stdout);
+++ // Since we support overriding these streams, we flush cerr
+++ // even though std::cerr is unbuffered
+++ Catch::cerr() << std::flush;
+++ Catch::clog() << std::flush;
+++ fflush(stderr);
+++
+++ dup2(m_originalStdout, 1);
+++ dup2(m_originalStderr, 2);
+++
+++ m_stdoutDest += m_stdoutFile.getContents();
+++ m_stderrDest += m_stderrFile.getContents();
+++ }
+++
+++#endif // CATCH_CONFIG_NEW_CAPTURE
+++
+++} // namespace Catch
+++
+++#if defined(CATCH_CONFIG_NEW_CAPTURE)
+++ #if defined(_MSC_VER)
+++ #undef dup
+++ #undef dup2
+++ #undef fileno
+++ #endif
+++#endif
+++
+++
+++
+++
+++#include <limits>
+++#include <stdexcept>
+++
+++namespace Catch {
+++
+++ Optional<unsigned int> parseUInt(std::string const& input, int base) {
+++ auto trimmed = trim( input );
+++ // std::stoull is annoying and accepts numbers starting with '-',
+++ // it just negates them into unsigned int
+++ if ( trimmed.empty() || trimmed[0] == '-' ) {
+++ return {};
+++ }
+++
+++ CATCH_TRY {
+++ size_t pos = 0;
+++ const auto ret = std::stoull( trimmed, &pos, base );
+++
+++ // We did not consume the whole input, so there is an issue
+++ // This can be bunch of different stuff, like multiple numbers
+++ // in the input, or invalid digits/characters and so on. Either
+++ // way, we do not want to return the partially parsed result.
+++ if ( pos != trimmed.size() ) {
+++ return {};
+++ }
+++ // Too large
+++ if ( ret > std::numeric_limits<unsigned int>::max() ) {
+++ return {};
+++ }
+++ return static_cast<unsigned int>(ret);
+++ }
+++ CATCH_CATCH_ANON( std::invalid_argument const& ) {
+++ // no conversion could be performed
+++ }
+++ CATCH_CATCH_ANON( std::out_of_range const& ) {
+++ // the input does not fit into an unsigned long long
+++ }
+++ return {};
+++ }
+++
+++} // namespace Catch
+++
+++
+++
+++
+++#include <cmath>
+++
+++namespace Catch {
+++
+++#if !defined(CATCH_CONFIG_POLYFILL_ISNAN)
+++ bool isnan(float f) {
+++ return std::isnan(f);
+++ }
+++ bool isnan(double d) {
+++ return std::isnan(d);
+++ }
+++#else
+++ // For now we only use this for embarcadero
+++ bool isnan(float f) {
+++ return std::_isnan(f);
+++ }
+++ bool isnan(double d) {
+++ return std::_isnan(d);
+++ }
+++#endif
+++
+++#if !defined( CATCH_CONFIG_GLOBAL_NEXTAFTER )
+++ float nextafter( float x, float y ) { return std::nextafter( x, y ); }
+++ double nextafter( double x, double y ) { return std::nextafter( x, y ); }
+++#else
+++ float nextafter( float x, float y ) { return ::nextafterf( x, y ); }
+++ double nextafter( double x, double y ) { return ::nextafter( x, y ); }
+++#endif
+++
+++} // end namespace Catch
+++
+++
+++
+++namespace Catch {
+++
+++namespace {
+++
+++#if defined(_MSC_VER)
+++#pragma warning(push)
+++#pragma warning(disable:4146) // we negate uint32 during the rotate
+++#endif
+++ // Safe rotr implementation thanks to John Regehr
+++ uint32_t rotate_right(uint32_t val, uint32_t count) {
+++ const uint32_t mask = 31;
+++ count &= mask;
+++ return (val >> count) | (val << (-count & mask));
+++ }
+++
+++#if defined(_MSC_VER)
+++#pragma warning(pop)
+++#endif
+++
+++}
+++
+++
+++ SimplePcg32::SimplePcg32(result_type seed_) {
+++ seed(seed_);
+++ }
+++
+++
+++ void SimplePcg32::seed(result_type seed_) {
+++ m_state = 0;
+++ (*this)();
+++ m_state += seed_;
+++ (*this)();
+++ }
+++
+++ void SimplePcg32::discard(uint64_t skip) {
+++ // We could implement this to run in O(log n) steps, but this
+++ // should suffice for our use case.
+++ for (uint64_t s = 0; s < skip; ++s) {
+++ static_cast<void>((*this)());
+++ }
+++ }
+++
+++ SimplePcg32::result_type SimplePcg32::operator()() {
+++ // prepare the output value
+++ const uint32_t xorshifted = static_cast<uint32_t>(((m_state >> 18u) ^ m_state) >> 27u);
+++ const auto output = rotate_right(xorshifted, m_state >> 59u);
+++
+++ // advance state
+++ m_state = m_state * 6364136223846793005ULL + s_inc;
+++
+++ return output;
+++ }
+++
+++ bool operator==(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+++ return lhs.m_state == rhs.m_state;
+++ }
+++
+++ bool operator!=(SimplePcg32 const& lhs, SimplePcg32 const& rhs) {
+++ return lhs.m_state != rhs.m_state;
+++ }
+++}
+++
+++
+++
+++
+++
+++#include <ctime>
+++#include <random>
+++
+++namespace Catch {
+++
+++ std::uint32_t generateRandomSeed( GenerateFrom from ) {
+++ switch ( from ) {
+++ case GenerateFrom::Time:
+++ return static_cast<std::uint32_t>( std::time( nullptr ) );
+++
+++ case GenerateFrom::Default:
+++ case GenerateFrom::RandomDevice: {
+++ std::random_device rd;
+++ return Detail::fillBitsFrom<std::uint32_t>( rd );
+++ }
+++
+++ default:
+++ CATCH_ERROR("Unknown generation method");
+++ }
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++namespace Catch {
+++ struct ReporterRegistry::ReporterRegistryImpl {
+++ std::vector<Detail::unique_ptr<EventListenerFactory>> listeners;
+++ std::map<std::string, IReporterFactoryPtr, Detail::CaseInsensitiveLess>
+++ factories;
+++ };
+++
+++ ReporterRegistry::ReporterRegistry():
+++ m_impl( Detail::make_unique<ReporterRegistryImpl>() ) {
+++ // Because it is impossible to move out of initializer list,
+++ // we have to add the elements manually
+++ m_impl->factories["Automake"] =
+++ Detail::make_unique<ReporterFactory<AutomakeReporter>>();
+++ m_impl->factories["compact"] =
+++ Detail::make_unique<ReporterFactory<CompactReporter>>();
+++ m_impl->factories["console"] =
+++ Detail::make_unique<ReporterFactory<ConsoleReporter>>();
+++ m_impl->factories["JUnit"] =
+++ Detail::make_unique<ReporterFactory<JunitReporter>>();
+++ m_impl->factories["SonarQube"] =
+++ Detail::make_unique<ReporterFactory<SonarQubeReporter>>();
+++ m_impl->factories["TAP"] =
+++ Detail::make_unique<ReporterFactory<TAPReporter>>();
+++ m_impl->factories["TeamCity"] =
+++ Detail::make_unique<ReporterFactory<TeamCityReporter>>();
+++ m_impl->factories["XML"] =
+++ Detail::make_unique<ReporterFactory<XmlReporter>>();
+++ m_impl->factories["JSON"] =
+++ Detail::make_unique<ReporterFactory<JsonReporter>>();
+++ }
+++
+++ ReporterRegistry::~ReporterRegistry() = default;
+++
+++ IEventListenerPtr
+++ ReporterRegistry::create( std::string const& name,
+++ ReporterConfig&& config ) const {
+++ auto it = m_impl->factories.find( name );
+++ if ( it == m_impl->factories.end() ) return nullptr;
+++ return it->second->create( CATCH_MOVE( config ) );
+++ }
+++
+++ void ReporterRegistry::registerReporter( std::string const& name,
+++ IReporterFactoryPtr factory ) {
+++ CATCH_ENFORCE( name.find( "::" ) == name.npos,
+++ "'::' is not allowed in reporter name: '" + name +
+++ '\'' );
+++ auto ret = m_impl->factories.emplace( name, CATCH_MOVE( factory ) );
+++ CATCH_ENFORCE( ret.second,
+++ "reporter using '" + name +
+++ "' as name was already registered" );
+++ }
+++ void ReporterRegistry::registerListener(
+++ Detail::unique_ptr<EventListenerFactory> factory ) {
+++ m_impl->listeners.push_back( CATCH_MOVE( factory ) );
+++ }
+++
+++ std::map<std::string,
+++ IReporterFactoryPtr,
+++ Detail::CaseInsensitiveLess> const&
+++ ReporterRegistry::getFactories() const {
+++ return m_impl->factories;
+++ }
+++
+++ std::vector<Detail::unique_ptr<EventListenerFactory>> const&
+++ ReporterRegistry::getListeners() const {
+++ return m_impl->listeners;
+++ }
+++} // namespace Catch
+++
+++
+++
+++
+++
+++#include <algorithm>
+++
+++namespace Catch {
+++
+++ namespace {
+++ struct kvPair {
+++ StringRef key, value;
+++ };
+++
+++ kvPair splitKVPair(StringRef kvString) {
+++ auto splitPos = static_cast<size_t>(
+++ std::find( kvString.begin(), kvString.end(), '=' ) -
+++ kvString.begin() );
+++
+++ return { kvString.substr( 0, splitPos ),
+++ kvString.substr( splitPos + 1, kvString.size() ) };
+++ }
+++ }
+++
+++ namespace Detail {
+++ std::vector<std::string> splitReporterSpec( StringRef reporterSpec ) {
+++ static constexpr auto separator = "::";
+++ static constexpr size_t separatorSize = 2;
+++
+++ size_t separatorPos = 0;
+++ auto findNextSeparator = [&reporterSpec]( size_t startPos ) {
+++ static_assert(
+++ separatorSize == 2,
+++ "The code below currently assumes 2 char separator" );
+++
+++ auto currentPos = startPos;
+++ do {
+++ while ( currentPos < reporterSpec.size() &&
+++ reporterSpec[currentPos] != separator[0] ) {
+++ ++currentPos;
+++ }
+++ if ( currentPos + 1 < reporterSpec.size() &&
+++ reporterSpec[currentPos + 1] == separator[1] ) {
+++ return currentPos;
+++ }
+++ ++currentPos;
+++ } while ( currentPos < reporterSpec.size() );
+++
+++ return static_cast<size_t>( -1 );
+++ };
+++
+++ std::vector<std::string> parts;
+++
+++ while ( separatorPos < reporterSpec.size() ) {
+++ const auto nextSeparator = findNextSeparator( separatorPos );
+++ parts.push_back( static_cast<std::string>( reporterSpec.substr(
+++ separatorPos, nextSeparator - separatorPos ) ) );
+++
+++ if ( nextSeparator == static_cast<size_t>( -1 ) ) {
+++ break;
+++ }
+++ separatorPos = nextSeparator + separatorSize;
+++ }
+++
+++ // Handle a separator at the end.
+++ // This is not a valid spec, but we want to do validation in a
+++ // centralized place
+++ if ( separatorPos == reporterSpec.size() ) {
+++ parts.emplace_back();
+++ }
+++
+++ return parts;
+++ }
+++
+++ Optional<ColourMode> stringToColourMode( StringRef colourMode ) {
+++ if ( colourMode == "default" ) {
+++ return ColourMode::PlatformDefault;
+++ } else if ( colourMode == "ansi" ) {
+++ return ColourMode::ANSI;
+++ } else if ( colourMode == "win32" ) {
+++ return ColourMode::Win32;
+++ } else if ( colourMode == "none" ) {
+++ return ColourMode::None;
+++ } else {
+++ return {};
+++ }
+++ }
+++ } // namespace Detail
+++
+++
+++ bool operator==( ReporterSpec const& lhs, ReporterSpec const& rhs ) {
+++ return lhs.m_name == rhs.m_name &&
+++ lhs.m_outputFileName == rhs.m_outputFileName &&
+++ lhs.m_colourMode == rhs.m_colourMode &&
+++ lhs.m_customOptions == rhs.m_customOptions;
+++ }
+++
+++ Optional<ReporterSpec> parseReporterSpec( StringRef reporterSpec ) {
+++ auto parts = Detail::splitReporterSpec( reporterSpec );
+++
+++ assert( parts.size() > 0 && "Split should never return empty vector" );
+++
+++ std::map<std::string, std::string> kvPairs;
+++ Optional<std::string> outputFileName;
+++ Optional<ColourMode> colourMode;
+++
+++ // First part is always reporter name, so we skip it
+++ for ( size_t i = 1; i < parts.size(); ++i ) {
+++ auto kv = splitKVPair( parts[i] );
+++ auto key = kv.key, value = kv.value;
+++
+++ if ( key.empty() || value.empty() ) { // NOLINT(bugprone-branch-clone)
+++ return {};
+++ } else if ( key[0] == 'X' ) {
+++ // This is a reporter-specific option, we don't check these
+++ // apart from basic sanity checks
+++ if ( key.size() == 1 ) {
+++ return {};
+++ }
+++
+++ auto ret = kvPairs.emplace( std::string(kv.key), std::string(kv.value) );
+++ if ( !ret.second ) {
+++ // Duplicated key. We might want to handle this differently,
+++ // e.g. by overwriting the existing value?
+++ return {};
+++ }
+++ } else if ( key == "out" ) {
+++ // Duplicated key
+++ if ( outputFileName ) {
+++ return {};
+++ }
+++ outputFileName = static_cast<std::string>( value );
+++ } else if ( key == "colour-mode" ) {
+++ // Duplicated key
+++ if ( colourMode ) {
+++ return {};
+++ }
+++ colourMode = Detail::stringToColourMode( value );
+++ // Parsing failed
+++ if ( !colourMode ) {
+++ return {};
+++ }
+++ } else {
+++ // Unrecognized option
+++ return {};
+++ }
+++ }
+++
+++ return ReporterSpec{ CATCH_MOVE( parts[0] ),
+++ CATCH_MOVE( outputFileName ),
+++ CATCH_MOVE( colourMode ),
+++ CATCH_MOVE( kvPairs ) };
+++ }
+++
+++ReporterSpec::ReporterSpec(
+++ std::string name,
+++ Optional<std::string> outputFileName,
+++ Optional<ColourMode> colourMode,
+++ std::map<std::string, std::string> customOptions ):
+++ m_name( CATCH_MOVE( name ) ),
+++ m_outputFileName( CATCH_MOVE( outputFileName ) ),
+++ m_colourMode( CATCH_MOVE( colourMode ) ),
+++ m_customOptions( CATCH_MOVE( customOptions ) ) {}
+++
+++} // namespace Catch
+++
+++
+++
+++namespace Catch {
+++
+++ bool isOk( ResultWas::OfType resultType ) {
+++ return ( resultType & ResultWas::FailureBit ) == 0;
+++ }
+++ bool isJustInfo( int flags ) {
+++ return flags == ResultWas::Info;
+++ }
+++
+++ ResultDisposition::Flags operator | ( ResultDisposition::Flags lhs, ResultDisposition::Flags rhs ) {
+++ return static_cast<ResultDisposition::Flags>( static_cast<int>( lhs ) | static_cast<int>( rhs ) );
+++ }
+++
+++ bool shouldContinueOnFailure( int flags ) { return ( flags & ResultDisposition::ContinueOnFailure ) != 0; }
+++ bool shouldSuppressFailure( int flags ) { return ( flags & ResultDisposition::SuppressFail ) != 0; }
+++
+++} // end namespace Catch
+++
+++
+++
+++#include <cstdio>
+++#include <sstream>
+++#include <vector>
+++
+++namespace Catch {
+++
+++ // This class encapsulates the idea of a pool of ostringstreams that can be reused.
+++ struct StringStreams {
+++ std::vector<Detail::unique_ptr<std::ostringstream>> m_streams;
+++ std::vector<std::size_t> m_unused;
+++ std::ostringstream m_referenceStream; // Used for copy state/ flags from
+++
+++ auto add() -> std::size_t {
+++ if( m_unused.empty() ) {
+++ m_streams.push_back( Detail::make_unique<std::ostringstream>() );
+++ return m_streams.size()-1;
+++ }
+++ else {
+++ auto index = m_unused.back();
+++ m_unused.pop_back();
+++ return index;
+++ }
+++ }
+++
+++ void release( std::size_t index ) {
+++ m_streams[index]->copyfmt( m_referenceStream ); // Restore initial flags and other state
+++ m_unused.push_back(index);
+++ }
+++ };
+++
+++ ReusableStringStream::ReusableStringStream()
+++ : m_index( Singleton<StringStreams>::getMutable().add() ),
+++ m_oss( Singleton<StringStreams>::getMutable().m_streams[m_index].get() )
+++ {}
+++
+++ ReusableStringStream::~ReusableStringStream() {
+++ static_cast<std::ostringstream*>( m_oss )->str("");
+++ m_oss->clear();
+++ Singleton<StringStreams>::getMutable().release( m_index );
+++ }
+++
+++ std::string ReusableStringStream::str() const {
+++ return static_cast<std::ostringstream*>( m_oss )->str();
+++ }
+++
+++ void ReusableStringStream::str( std::string const& str ) {
+++ static_cast<std::ostringstream*>( m_oss )->str( str );
+++ }
+++
+++
+++}
+++
+++
+++
+++
+++#include <cassert>
+++#include <algorithm>
+++
+++namespace Catch {
+++
+++ namespace Generators {
+++ namespace {
+++ struct GeneratorTracker final : TestCaseTracking::TrackerBase,
+++ IGeneratorTracker {
+++ GeneratorBasePtr m_generator;
+++
+++ GeneratorTracker(
+++ TestCaseTracking::NameAndLocation&& nameAndLocation,
+++ TrackerContext& ctx,
+++ ITracker* parent ):
+++ TrackerBase( CATCH_MOVE( nameAndLocation ), ctx, parent ) {}
+++
+++ static GeneratorTracker*
+++ acquire( TrackerContext& ctx,
+++ TestCaseTracking::NameAndLocationRef const&
+++ nameAndLocation ) {
+++ GeneratorTracker* tracker;
+++
+++ ITracker& currentTracker = ctx.currentTracker();
+++ // Under specific circumstances, the generator we want
+++ // to acquire is also the current tracker. If this is
+++ // the case, we have to avoid looking through current
+++ // tracker's children, and instead return the current
+++ // tracker.
+++ // A case where this check is important is e.g.
+++ // for (int i = 0; i < 5; ++i) {
+++ // int n = GENERATE(1, 2);
+++ // }
+++ //
+++ // without it, the code above creates 5 nested generators.
+++ if ( currentTracker.nameAndLocation() == nameAndLocation ) {
+++ auto thisTracker = currentTracker.parent()->findChild(
+++ nameAndLocation );
+++ assert( thisTracker );
+++ assert( thisTracker->isGeneratorTracker() );
+++ tracker = static_cast<GeneratorTracker*>( thisTracker );
+++ } else if ( ITracker* childTracker =
+++ currentTracker.findChild(
+++ nameAndLocation ) ) {
+++ assert( childTracker );
+++ assert( childTracker->isGeneratorTracker() );
+++ tracker =
+++ static_cast<GeneratorTracker*>( childTracker );
+++ } else {
+++ return nullptr;
+++ }
+++
+++ if ( !tracker->isComplete() ) { tracker->open(); }
+++
+++ return tracker;
+++ }
+++
+++ // TrackerBase interface
+++ bool isGeneratorTracker() const override { return true; }
+++ auto hasGenerator() const -> bool override {
+++ return !!m_generator;
+++ }
+++ void close() override {
+++ TrackerBase::close();
+++ // If a generator has a child (it is followed by a section)
+++ // and none of its children have started, then we must wait
+++ // until later to start consuming its values.
+++ // This catches cases where `GENERATE` is placed between two
+++ // `SECTION`s.
+++ // **The check for m_children.empty cannot be removed**.
+++ // doing so would break `GENERATE` _not_ followed by
+++ // `SECTION`s.
+++ const bool should_wait_for_child = [&]() {
+++ // No children -> nobody to wait for
+++ if ( m_children.empty() ) { return false; }
+++ // If at least one child started executing, don't wait
+++ if ( std::find_if(
+++ m_children.begin(),
+++ m_children.end(),
+++ []( TestCaseTracking::ITrackerPtr const&
+++ tracker ) {
+++ return tracker->hasStarted();
+++ } ) != m_children.end() ) {
+++ return false;
+++ }
+++
+++ // No children have started. We need to check if they
+++ // _can_ start, and thus we should wait for them, or
+++ // they cannot start (due to filters), and we shouldn't
+++ // wait for them
+++ ITracker* parent = m_parent;
+++ // This is safe: there is always at least one section
+++ // tracker in a test case tracking tree
+++ while ( !parent->isSectionTracker() ) {
+++ parent = parent->parent();
+++ }
+++ assert( parent &&
+++ "Missing root (test case) level section" );
+++
+++ auto const& parentSection =
+++ static_cast<SectionTracker const&>( *parent );
+++ auto const& filters = parentSection.getFilters();
+++ // No filters -> no restrictions on running sections
+++ if ( filters.empty() ) { return true; }
+++
+++ for ( auto const& child : m_children ) {
+++ if ( child->isSectionTracker() &&
+++ std::find( filters.begin(),
+++ filters.end(),
+++ static_cast<SectionTracker const&>(
+++ *child )
+++ .trimmedName() ) !=
+++ filters.end() ) {
+++ return true;
+++ }
+++ }
+++ return false;
+++ }();
+++
+++ // This check is a bit tricky, because m_generator->next()
+++ // has a side-effect, where it consumes generator's current
+++ // value, but we do not want to invoke the side-effect if
+++ // this generator is still waiting for any child to start.
+++ assert( m_generator && "Tracker without generator" );
+++ if ( should_wait_for_child ||
+++ ( m_runState == CompletedSuccessfully &&
+++ m_generator->countedNext() ) ) {
+++ m_children.clear();
+++ m_runState = Executing;
+++ }
+++ }
+++
+++ // IGeneratorTracker interface
+++ auto getGenerator() const -> GeneratorBasePtr const& override {
+++ return m_generator;
+++ }
+++ void setGenerator( GeneratorBasePtr&& generator ) override {
+++ m_generator = CATCH_MOVE( generator );
+++ }
+++ };
+++ } // namespace
+++ }
+++
+++ RunContext::RunContext(IConfig const* _config, IEventListenerPtr&& reporter)
+++ : m_runInfo(_config->name()),
+++ m_config(_config),
+++ m_reporter(CATCH_MOVE(reporter)),
+++ m_lastAssertionInfo{ StringRef(), SourceLineInfo("",0), StringRef(), ResultDisposition::Normal },
+++ m_includeSuccessfulResults( m_config->includeSuccessfulResults() || m_reporter->getPreferences().shouldReportAllAssertions )
+++ {
+++ getCurrentMutableContext().setResultCapture( this );
+++ m_reporter->testRunStarting(m_runInfo);
+++ }
+++
+++ RunContext::~RunContext() {
+++ m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, aborting()));
+++ }
+++
+++ Totals RunContext::runTest(TestCaseHandle const& testCase) {
+++ const Totals prevTotals = m_totals;
+++
+++ auto const& testInfo = testCase.getTestCaseInfo();
+++ m_reporter->testCaseStarting(testInfo);
+++ m_activeTestCase = &testCase;
+++
+++
+++ ITracker& rootTracker = m_trackerContext.startRun();
+++ assert(rootTracker.isSectionTracker());
+++ static_cast<SectionTracker&>(rootTracker).addInitialFilters(m_config->getSectionsToRun());
+++
+++ // We intentionally only seed the internal RNG once per test case,
+++ // before it is first invoked. The reason for that is a complex
+++ // interplay of generator/section implementation details and the
+++ // Random*Generator types.
+++ //
+++ // The issue boils down to us needing to seed the Random*Generators
+++ // with different seed each, so that they return different sequences
+++ // of random numbers. We do this by giving them a number from the
+++ // shared RNG instance as their seed.
+++ //
+++ // However, this runs into an issue if the reseeding happens each
+++ // time the test case is entered (as opposed to first time only),
+++ // because multiple generators could get the same seed, e.g. in
+++ // ```cpp
+++ // TEST_CASE() {
+++ // auto i = GENERATE(take(10, random(0, 100));
+++ // SECTION("A") {
+++ // auto j = GENERATE(take(10, random(0, 100));
+++ // }
+++ // SECTION("B") {
+++ // auto k = GENERATE(take(10, random(0, 100));
+++ // }
+++ // }
+++ // ```
+++ // `i` and `j` would properly return values from different sequences,
+++ // but `i` and `k` would return the same sequence, because their seed
+++ // would be the same.
+++ // (The reason their seeds would be the same is that the generator
+++ // for k would be initialized when the test case is entered the second
+++ // time, after the shared RNG instance was reset to the same value
+++ // it had when the generator for i was initialized.)
+++ seedRng( *m_config );
+++
+++ uint64_t testRuns = 0;
+++ std::string redirectedCout;
+++ std::string redirectedCerr;
+++ do {
+++ m_trackerContext.startCycle();
+++ m_testCaseTracker = &SectionTracker::acquire(m_trackerContext, TestCaseTracking::NameAndLocationRef(testInfo.name, testInfo.lineInfo));
+++
+++ m_reporter->testCasePartialStarting(testInfo, testRuns);
+++
+++ const auto beforeRunTotals = m_totals;
+++ std::string oneRunCout, oneRunCerr;
+++ runCurrentTest(oneRunCout, oneRunCerr);
+++ redirectedCout += oneRunCout;
+++ redirectedCerr += oneRunCerr;
+++
+++ const auto singleRunTotals = m_totals.delta(beforeRunTotals);
+++ auto statsForOneRun = TestCaseStats(testInfo, singleRunTotals, CATCH_MOVE(oneRunCout), CATCH_MOVE(oneRunCerr), aborting());
+++
+++ m_reporter->testCasePartialEnded(statsForOneRun, testRuns);
+++ ++testRuns;
+++ } while (!m_testCaseTracker->isSuccessfullyCompleted() && !aborting());
+++
+++ Totals deltaTotals = m_totals.delta(prevTotals);
+++ if (testInfo.expectedToFail() && deltaTotals.testCases.passed > 0) {
+++ deltaTotals.assertions.failed++;
+++ deltaTotals.testCases.passed--;
+++ deltaTotals.testCases.failed++;
+++ }
+++ m_totals.testCases += deltaTotals.testCases;
+++ m_reporter->testCaseEnded(TestCaseStats(testInfo,
+++ deltaTotals,
+++ CATCH_MOVE(redirectedCout),
+++ CATCH_MOVE(redirectedCerr),
+++ aborting()));
+++
+++ m_activeTestCase = nullptr;
+++ m_testCaseTracker = nullptr;
+++
+++ return deltaTotals;
+++ }
+++
+++
+++ void RunContext::assertionEnded(AssertionResult&& result) {
+++ if (result.getResultType() == ResultWas::Ok) {
+++ m_totals.assertions.passed++;
+++ m_lastAssertionPassed = true;
+++ } else if (result.getResultType() == ResultWas::ExplicitSkip) {
+++ m_totals.assertions.skipped++;
+++ m_lastAssertionPassed = true;
+++ } else if (!result.succeeded()) {
+++ m_lastAssertionPassed = false;
+++ if (result.isOk()) {
+++ }
+++ else if( m_activeTestCase->getTestCaseInfo().okToFail() )
+++ m_totals.assertions.failedButOk++;
+++ else
+++ m_totals.assertions.failed++;
+++ }
+++ else {
+++ m_lastAssertionPassed = true;
+++ }
+++
+++ m_reporter->assertionEnded(AssertionStats(result, m_messages, m_totals));
+++
+++ if ( result.getResultType() != ResultWas::Warning ) {
+++ m_messageScopes.clear();
+++ }
+++
+++ // Reset working state. assertion info will be reset after
+++ // populateReaction is run if it is needed
+++ m_lastResult = CATCH_MOVE( result );
+++ }
+++ void RunContext::resetAssertionInfo() {
+++ m_lastAssertionInfo.macroName = StringRef();
+++ m_lastAssertionInfo.capturedExpression = "{Unknown expression after the reported line}"_sr;
+++ m_lastAssertionInfo.resultDisposition = ResultDisposition::Normal;
+++ }
+++
+++ void RunContext::notifyAssertionStarted( AssertionInfo const& info ) {
+++ m_reporter->assertionStarting( info );
+++ }
+++
+++ bool RunContext::sectionStarted( StringRef sectionName,
+++ SourceLineInfo const& sectionLineInfo,
+++ Counts& assertions ) {
+++ ITracker& sectionTracker =
+++ SectionTracker::acquire( m_trackerContext,
+++ TestCaseTracking::NameAndLocationRef(
+++ sectionName, sectionLineInfo ) );
+++
+++ if (!sectionTracker.isOpen())
+++ return false;
+++ m_activeSections.push_back(§ionTracker);
+++
+++ SectionInfo sectionInfo( sectionLineInfo, static_cast<std::string>(sectionName) );
+++ m_lastAssertionInfo.lineInfo = sectionInfo.lineInfo;
+++
+++ m_reporter->sectionStarting(sectionInfo);
+++
+++ assertions = m_totals.assertions;
+++
+++ return true;
+++ }
+++ IGeneratorTracker*
+++ RunContext::acquireGeneratorTracker( StringRef generatorName,
+++ SourceLineInfo const& lineInfo ) {
+++ using namespace Generators;
+++ GeneratorTracker* tracker = GeneratorTracker::acquire(
+++ m_trackerContext,
+++ TestCaseTracking::NameAndLocationRef(
+++ generatorName, lineInfo ) );
+++ m_lastAssertionInfo.lineInfo = lineInfo;
+++ return tracker;
+++ }
+++
+++ IGeneratorTracker* RunContext::createGeneratorTracker(
+++ StringRef generatorName,
+++ SourceLineInfo lineInfo,
+++ Generators::GeneratorBasePtr&& generator ) {
+++
+++ auto nameAndLoc = TestCaseTracking::NameAndLocation( static_cast<std::string>( generatorName ), lineInfo );
+++ auto& currentTracker = m_trackerContext.currentTracker();
+++ assert(
+++ currentTracker.nameAndLocation() != nameAndLoc &&
+++ "Trying to create tracker for a genreator that already has one" );
+++
+++ auto newTracker = Catch::Detail::make_unique<Generators::GeneratorTracker>(
+++ CATCH_MOVE(nameAndLoc), m_trackerContext, ¤tTracker );
+++ auto ret = newTracker.get();
+++ currentTracker.addChild( CATCH_MOVE( newTracker ) );
+++
+++ ret->setGenerator( CATCH_MOVE( generator ) );
+++ ret->open();
+++ return ret;
+++ }
+++
+++ bool RunContext::testForMissingAssertions(Counts& assertions) {
+++ if (assertions.total() != 0)
+++ return false;
+++ if (!m_config->warnAboutMissingAssertions())
+++ return false;
+++ if (m_trackerContext.currentTracker().hasChildren())
+++ return false;
+++ m_totals.assertions.failed++;
+++ assertions.failed++;
+++ return true;
+++ }
+++
+++ void RunContext::sectionEnded(SectionEndInfo&& endInfo) {
+++ Counts assertions = m_totals.assertions - endInfo.prevAssertions;
+++ bool missingAssertions = testForMissingAssertions(assertions);
+++
+++ if (!m_activeSections.empty()) {
+++ m_activeSections.back()->close();
+++ m_activeSections.pop_back();
+++ }
+++
+++ m_reporter->sectionEnded(SectionStats(CATCH_MOVE(endInfo.sectionInfo), assertions, endInfo.durationInSeconds, missingAssertions));
+++ m_messages.clear();
+++ m_messageScopes.clear();
+++ }
+++
+++ void RunContext::sectionEndedEarly(SectionEndInfo&& endInfo) {
+++ if ( m_unfinishedSections.empty() ) {
+++ m_activeSections.back()->fail();
+++ } else {
+++ m_activeSections.back()->close();
+++ }
+++ m_activeSections.pop_back();
+++
+++ m_unfinishedSections.push_back(CATCH_MOVE(endInfo));
+++ }
+++
+++ void RunContext::benchmarkPreparing( StringRef name ) {
+++ m_reporter->benchmarkPreparing(name);
+++ }
+++ void RunContext::benchmarkStarting( BenchmarkInfo const& info ) {
+++ m_reporter->benchmarkStarting( info );
+++ }
+++ void RunContext::benchmarkEnded( BenchmarkStats<> const& stats ) {
+++ m_reporter->benchmarkEnded( stats );
+++ }
+++ void RunContext::benchmarkFailed( StringRef error ) {
+++ m_reporter->benchmarkFailed( error );
+++ }
+++
+++ void RunContext::pushScopedMessage(MessageInfo const & message) {
+++ m_messages.push_back(message);
+++ }
+++
+++ void RunContext::popScopedMessage(MessageInfo const & message) {
+++ m_messages.erase(std::remove(m_messages.begin(), m_messages.end(), message), m_messages.end());
+++ }
+++
+++ void RunContext::emplaceUnscopedMessage( MessageBuilder&& builder ) {
+++ m_messageScopes.emplace_back( CATCH_MOVE(builder) );
+++ }
+++
+++ std::string RunContext::getCurrentTestName() const {
+++ return m_activeTestCase
+++ ? m_activeTestCase->getTestCaseInfo().name
+++ : std::string();
+++ }
+++
+++ const AssertionResult * RunContext::getLastResult() const {
+++ return &(*m_lastResult);
+++ }
+++
+++ void RunContext::exceptionEarlyReported() {
+++ m_shouldReportUnexpected = false;
+++ }
+++
+++ void RunContext::handleFatalErrorCondition( StringRef message ) {
+++ // First notify reporter that bad things happened
+++ m_reporter->fatalErrorEncountered(message);
+++
+++ // Don't rebuild the result -- the stringification itself can cause more fatal errors
+++ // Instead, fake a result data.
+++ AssertionResultData tempResult( ResultWas::FatalErrorCondition, { false } );
+++ tempResult.message = static_cast<std::string>(message);
+++ AssertionResult result(m_lastAssertionInfo, CATCH_MOVE(tempResult));
+++
+++ assertionEnded(CATCH_MOVE(result) );
+++ resetAssertionInfo();
+++
+++ // Best effort cleanup for sections that have not been destructed yet
+++ // Since this is a fatal error, we have not had and won't have the opportunity to destruct them properly
+++ while (!m_activeSections.empty()) {
+++ auto nl = m_activeSections.back()->nameAndLocation();
+++ SectionEndInfo endInfo{ SectionInfo(CATCH_MOVE(nl.location), CATCH_MOVE(nl.name)), {}, 0.0 };
+++ sectionEndedEarly(CATCH_MOVE(endInfo));
+++ }
+++ handleUnfinishedSections();
+++
+++ // Recreate section for test case (as we will lose the one that was in scope)
+++ auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+++ SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+++
+++ Counts assertions;
+++ assertions.failed = 1;
+++ SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, 0, false);
+++ m_reporter->sectionEnded(testCaseSectionStats);
+++
+++ auto const& testInfo = m_activeTestCase->getTestCaseInfo();
+++
+++ Totals deltaTotals;
+++ deltaTotals.testCases.failed = 1;
+++ deltaTotals.assertions.failed = 1;
+++ m_reporter->testCaseEnded(TestCaseStats(testInfo,
+++ deltaTotals,
+++ std::string(),
+++ std::string(),
+++ false));
+++ m_totals.testCases.failed++;
+++ m_reporter->testRunEnded(TestRunStats(m_runInfo, m_totals, false));
+++ }
+++
+++ bool RunContext::lastAssertionPassed() {
+++ return m_lastAssertionPassed;
+++ }
+++
+++ void RunContext::assertionPassed() {
+++ m_lastAssertionPassed = true;
+++ ++m_totals.assertions.passed;
+++ resetAssertionInfo();
+++ m_messageScopes.clear();
+++ }
+++
+++ bool RunContext::aborting() const {
+++ return m_totals.assertions.failed >= static_cast<std::size_t>(m_config->abortAfter());
+++ }
+++
+++ void RunContext::runCurrentTest(std::string & redirectedCout, std::string & redirectedCerr) {
+++ auto const& testCaseInfo = m_activeTestCase->getTestCaseInfo();
+++ SectionInfo testCaseSection(testCaseInfo.lineInfo, testCaseInfo.name);
+++ m_reporter->sectionStarting(testCaseSection);
+++ Counts prevAssertions = m_totals.assertions;
+++ double duration = 0;
+++ m_shouldReportUnexpected = true;
+++ m_lastAssertionInfo = { "TEST_CASE"_sr, testCaseInfo.lineInfo, StringRef(), ResultDisposition::Normal };
+++
+++ Timer timer;
+++ CATCH_TRY {
+++ if (m_reporter->getPreferences().shouldRedirectStdOut) {
+++#if !defined(CATCH_CONFIG_EXPERIMENTAL_REDIRECT)
+++ RedirectedStreams redirectedStreams(redirectedCout, redirectedCerr);
+++
+++ timer.start();
+++ invokeActiveTestCase();
+++#else
+++ OutputRedirect r(redirectedCout, redirectedCerr);
+++ timer.start();
+++ invokeActiveTestCase();
+++#endif
+++ } else {
+++ timer.start();
+++ invokeActiveTestCase();
+++ }
+++ duration = timer.getElapsedSeconds();
+++ } CATCH_CATCH_ANON (TestFailureException&) {
+++ // This just means the test was aborted due to failure
+++ } CATCH_CATCH_ANON (TestSkipException&) {
+++ // This just means the test was explicitly skipped
+++ } CATCH_CATCH_ALL {
+++ // Under CATCH_CONFIG_FAST_COMPILE, unexpected exceptions under REQUIRE assertions
+++ // are reported without translation at the point of origin.
+++ if( m_shouldReportUnexpected ) {
+++ AssertionReaction dummyReaction;
+++ handleUnexpectedInflightException( m_lastAssertionInfo, translateActiveException(), dummyReaction );
+++ }
+++ }
+++ Counts assertions = m_totals.assertions - prevAssertions;
+++ bool missingAssertions = testForMissingAssertions(assertions);
+++
+++ m_testCaseTracker->close();
+++ handleUnfinishedSections();
+++ m_messages.clear();
+++ m_messageScopes.clear();
+++
+++ SectionStats testCaseSectionStats(CATCH_MOVE(testCaseSection), assertions, duration, missingAssertions);
+++ m_reporter->sectionEnded(testCaseSectionStats);
+++ }
+++
+++ void RunContext::invokeActiveTestCase() {
+++ // We need to engage a handler for signals/structured exceptions
+++ // before running the tests themselves, or the binary can crash
+++ // without failed test being reported.
+++ FatalConditionHandlerGuard _(&m_fatalConditionhandler);
+++ // We keep having issue where some compilers warn about an unused
+++ // variable, even though the type has non-trivial constructor and
+++ // destructor. This is annoying and ugly, but it makes them stfu.
+++ (void)_;
+++
+++ m_activeTestCase->invoke();
+++ }
+++
+++ void RunContext::handleUnfinishedSections() {
+++ // If sections ended prematurely due to an exception we stored their
+++ // infos here so we can tear them down outside the unwind process.
+++ for (auto it = m_unfinishedSections.rbegin(),
+++ itEnd = m_unfinishedSections.rend();
+++ it != itEnd;
+++ ++it)
+++ sectionEnded(CATCH_MOVE(*it));
+++ m_unfinishedSections.clear();
+++ }
+++
+++ void RunContext::handleExpr(
+++ AssertionInfo const& info,
+++ ITransientExpression const& expr,
+++ AssertionReaction& reaction
+++ ) {
+++ bool negated = isFalseTest( info.resultDisposition );
+++ bool result = expr.getResult() != negated;
+++
+++ if( result ) {
+++ if (!m_includeSuccessfulResults) {
+++ assertionPassed();
+++ }
+++ else {
+++ reportExpr(info, ResultWas::Ok, &expr, negated);
+++ }
+++ }
+++ else {
+++ reportExpr(info, ResultWas::ExpressionFailed, &expr, negated );
+++ populateReaction( reaction );
+++ }
+++ resetAssertionInfo();
+++ }
+++ void RunContext::reportExpr(
+++ AssertionInfo const &info,
+++ ResultWas::OfType resultType,
+++ ITransientExpression const *expr,
+++ bool negated ) {
+++
+++ m_lastAssertionInfo = info;
+++ AssertionResultData data( resultType, LazyExpression( negated ) );
+++
+++ AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
+++ assertionResult.m_resultData.lazyExpression.m_transientExpression = expr;
+++
+++ assertionEnded( CATCH_MOVE(assertionResult) );
+++ }
+++
+++ void RunContext::handleMessage(
+++ AssertionInfo const& info,
+++ ResultWas::OfType resultType,
+++ StringRef message,
+++ AssertionReaction& reaction
+++ ) {
+++ m_lastAssertionInfo = info;
+++
+++ AssertionResultData data( resultType, LazyExpression( false ) );
+++ data.message = static_cast<std::string>(message);
+++ AssertionResult assertionResult{ m_lastAssertionInfo,
+++ CATCH_MOVE( data ) };
+++
+++ const auto isOk = assertionResult.isOk();
+++ assertionEnded( CATCH_MOVE(assertionResult) );
+++ if ( !isOk ) {
+++ populateReaction( reaction );
+++ } else if ( resultType == ResultWas::ExplicitSkip ) {
+++ // TODO: Need to handle this explicitly, as ExplicitSkip is
+++ // considered "OK"
+++ reaction.shouldSkip = true;
+++ }
+++ resetAssertionInfo();
+++ }
+++ void RunContext::handleUnexpectedExceptionNotThrown(
+++ AssertionInfo const& info,
+++ AssertionReaction& reaction
+++ ) {
+++ handleNonExpr(info, Catch::ResultWas::DidntThrowException, reaction);
+++ }
+++
+++ void RunContext::handleUnexpectedInflightException(
+++ AssertionInfo const& info,
+++ std::string&& message,
+++ AssertionReaction& reaction
+++ ) {
+++ m_lastAssertionInfo = info;
+++
+++ AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+++ data.message = CATCH_MOVE(message);
+++ AssertionResult assertionResult{ info, CATCH_MOVE(data) };
+++ assertionEnded( CATCH_MOVE(assertionResult) );
+++ populateReaction( reaction );
+++ resetAssertionInfo();
+++ }
+++
+++ void RunContext::populateReaction( AssertionReaction& reaction ) {
+++ reaction.shouldDebugBreak = m_config->shouldDebugBreak();
+++ reaction.shouldThrow = aborting() || (m_lastAssertionInfo.resultDisposition & ResultDisposition::Normal);
+++ }
+++
+++ void RunContext::handleIncomplete(
+++ AssertionInfo const& info
+++ ) {
+++ using namespace std::string_literals;
+++ m_lastAssertionInfo = info;
+++
+++ AssertionResultData data( ResultWas::ThrewException, LazyExpression( false ) );
+++ data.message = "Exception translation was disabled by CATCH_CONFIG_FAST_COMPILE"s;
+++ AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
+++ assertionEnded( CATCH_MOVE(assertionResult) );
+++ resetAssertionInfo();
+++ }
+++ void RunContext::handleNonExpr(
+++ AssertionInfo const &info,
+++ ResultWas::OfType resultType,
+++ AssertionReaction &reaction
+++ ) {
+++ m_lastAssertionInfo = info;
+++
+++ AssertionResultData data( resultType, LazyExpression( false ) );
+++ AssertionResult assertionResult{ info, CATCH_MOVE( data ) };
+++
+++ const auto isOk = assertionResult.isOk();
+++ assertionEnded( CATCH_MOVE(assertionResult) );
+++ if ( !isOk ) { populateReaction( reaction ); }
+++ resetAssertionInfo();
+++ }
+++
+++
+++ IResultCapture& getResultCapture() {
+++ if (auto* capture = getCurrentContext().getResultCapture())
+++ return *capture;
+++ else
+++ CATCH_INTERNAL_ERROR("No result capture instance");
+++ }
+++
+++ void seedRng(IConfig const& config) {
+++ sharedRng().seed(config.rngSeed());
+++ }
+++
+++ unsigned int rngSeed() {
+++ return getCurrentContext().getConfig()->rngSeed();
+++ }
+++
+++}
+++
+++
+++
+++namespace Catch {
+++
+++ Section::Section( SectionInfo&& info ):
+++ m_info( CATCH_MOVE( info ) ),
+++ m_sectionIncluded(
+++ getResultCapture().sectionStarted( m_info.name, m_info.lineInfo, m_assertions ) ) {
+++ // Non-"included" sections will not use the timing information
+++ // anyway, so don't bother with the potential syscall.
+++ if (m_sectionIncluded) {
+++ m_timer.start();
+++ }
+++ }
+++
+++ Section::Section( SourceLineInfo const& _lineInfo,
+++ StringRef _name,
+++ const char* const ):
+++ m_info( { "invalid", static_cast<std::size_t>( -1 ) }, std::string{} ),
+++ m_sectionIncluded(
+++ getResultCapture().sectionStarted( _name, _lineInfo, m_assertions ) ) {
+++ // We delay initialization the SectionInfo member until we know
+++ // this section needs it, so we avoid allocating std::string for name.
+++ // We also delay timer start to avoid the potential syscall unless we
+++ // will actually use the result.
+++ if ( m_sectionIncluded ) {
+++ m_info.name = static_cast<std::string>( _name );
+++ m_info.lineInfo = _lineInfo;
+++ m_timer.start();
+++ }
+++ }
+++
+++ Section::~Section() {
+++ if( m_sectionIncluded ) {
+++ SectionEndInfo endInfo{ CATCH_MOVE(m_info), m_assertions, m_timer.getElapsedSeconds() };
+++ if ( uncaught_exceptions() ) {
+++ getResultCapture().sectionEndedEarly( CATCH_MOVE(endInfo) );
+++ } else {
+++ getResultCapture().sectionEnded( CATCH_MOVE( endInfo ) );
+++ }
+++ }
+++ }
+++
+++ // This indicates whether the section should be executed or not
+++ Section::operator bool() const {
+++ return m_sectionIncluded;
+++ }
+++
+++
+++} // end namespace Catch
+++
+++
+++
+++#include <vector>
+++
+++namespace Catch {
+++
+++ namespace {
+++ static auto getSingletons() -> std::vector<ISingleton*>*& {
+++ static std::vector<ISingleton*>* g_singletons = nullptr;
+++ if( !g_singletons )
+++ g_singletons = new std::vector<ISingleton*>();
+++ return g_singletons;
+++ }
+++ }
+++
+++ ISingleton::~ISingleton() = default;
+++
+++ void addSingleton(ISingleton* singleton ) {
+++ getSingletons()->push_back( singleton );
+++ }
+++ void cleanupSingletons() {
+++ auto& singletons = getSingletons();
+++ for( auto singleton : *singletons )
+++ delete singleton;
+++ delete singletons;
+++ singletons = nullptr;
+++ }
+++
+++} // namespace Catch
+++
+++
+++
+++#include <cstring>
+++#include <ostream>
+++
+++namespace Catch {
+++
+++ bool SourceLineInfo::operator == ( SourceLineInfo const& other ) const noexcept {
+++ return line == other.line && (file == other.file || std::strcmp(file, other.file) == 0);
+++ }
+++ bool SourceLineInfo::operator < ( SourceLineInfo const& other ) const noexcept {
+++ // We can assume that the same file will usually have the same pointer.
+++ // Thus, if the pointers are the same, there is no point in calling the strcmp
+++ return line < other.line || ( line == other.line && file != other.file && (std::strcmp(file, other.file) < 0));
+++ }
+++
+++ std::ostream& operator << ( std::ostream& os, SourceLineInfo const& info ) {
+++#ifndef __GNUG__
+++ os << info.file << '(' << info.line << ')';
+++#else
+++ os << info.file << ':' << info.line;
+++#endif
+++ return os;
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++namespace Catch {
+++#if !defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+++ void StartupExceptionRegistry::add( std::exception_ptr const& exception ) noexcept {
+++ CATCH_TRY {
+++ m_exceptions.push_back(exception);
+++ } CATCH_CATCH_ALL {
+++ // If we run out of memory during start-up there's really not a lot more we can do about it
+++ std::terminate();
+++ }
+++ }
+++
+++ std::vector<std::exception_ptr> const& StartupExceptionRegistry::getExceptions() const noexcept {
+++ return m_exceptions;
+++ }
+++#endif
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++
+++#include <iostream>
+++
+++namespace Catch {
+++
+++// If you #define this you must implement these functions
+++#if !defined( CATCH_CONFIG_NOSTDOUT )
+++ std::ostream& cout() { return std::cout; }
+++ std::ostream& cerr() { return std::cerr; }
+++ std::ostream& clog() { return std::clog; }
+++#endif
+++
+++} // namespace Catch
+++
+++
+++
+++#include <ostream>
+++#include <cstring>
+++#include <cctype>
+++#include <vector>
+++
+++namespace Catch {
+++
+++ bool startsWith( std::string const& s, std::string const& prefix ) {
+++ return s.size() >= prefix.size() && std::equal(prefix.begin(), prefix.end(), s.begin());
+++ }
+++ bool startsWith( StringRef s, char prefix ) {
+++ return !s.empty() && s[0] == prefix;
+++ }
+++ bool endsWith( std::string const& s, std::string const& suffix ) {
+++ return s.size() >= suffix.size() && std::equal(suffix.rbegin(), suffix.rend(), s.rbegin());
+++ }
+++ bool endsWith( std::string const& s, char suffix ) {
+++ return !s.empty() && s[s.size()-1] == suffix;
+++ }
+++ bool contains( std::string const& s, std::string const& infix ) {
+++ return s.find( infix ) != std::string::npos;
+++ }
+++ void toLowerInPlace( std::string& s ) {
+++ for ( char& c : s ) {
+++ c = toLower( c );
+++ }
+++ }
+++ std::string toLower( std::string const& s ) {
+++ std::string lc = s;
+++ toLowerInPlace( lc );
+++ return lc;
+++ }
+++ char toLower(char c) {
+++ return static_cast<char>(std::tolower(static_cast<unsigned char>(c)));
+++ }
+++
+++ std::string trim( std::string const& str ) {
+++ static char const* whitespaceChars = "\n\r\t ";
+++ std::string::size_type start = str.find_first_not_of( whitespaceChars );
+++ std::string::size_type end = str.find_last_not_of( whitespaceChars );
+++
+++ return start != std::string::npos ? str.substr( start, 1+end-start ) : std::string();
+++ }
+++
+++ StringRef trim(StringRef ref) {
+++ const auto is_ws = [](char c) {
+++ return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+++ };
+++ size_t real_begin = 0;
+++ while (real_begin < ref.size() && is_ws(ref[real_begin])) { ++real_begin; }
+++ size_t real_end = ref.size();
+++ while (real_end > real_begin && is_ws(ref[real_end - 1])) { --real_end; }
+++
+++ return ref.substr(real_begin, real_end - real_begin);
+++ }
+++
+++ bool replaceInPlace( std::string& str, std::string const& replaceThis, std::string const& withThis ) {
+++ std::size_t i = str.find( replaceThis );
+++ if (i == std::string::npos) {
+++ return false;
+++ }
+++ std::size_t copyBegin = 0;
+++ std::string origStr = CATCH_MOVE(str);
+++ str.clear();
+++ // There is at least one replacement, so reserve with the best guess
+++ // we can make without actually counting the number of occurences.
+++ str.reserve(origStr.size() - replaceThis.size() + withThis.size());
+++ do {
+++ str.append(origStr, copyBegin, i-copyBegin );
+++ str += withThis;
+++ copyBegin = i + replaceThis.size();
+++ if( copyBegin < origStr.size() )
+++ i = origStr.find( replaceThis, copyBegin );
+++ else
+++ i = std::string::npos;
+++ } while( i != std::string::npos );
+++ if ( copyBegin < origStr.size() ) {
+++ str.append(origStr, copyBegin, origStr.size() );
+++ }
+++ return true;
+++ }
+++
+++ std::vector<StringRef> splitStringRef( StringRef str, char delimiter ) {
+++ std::vector<StringRef> subStrings;
+++ std::size_t start = 0;
+++ for(std::size_t pos = 0; pos < str.size(); ++pos ) {
+++ if( str[pos] == delimiter ) {
+++ if( pos - start > 1 )
+++ subStrings.push_back( str.substr( start, pos-start ) );
+++ start = pos+1;
+++ }
+++ }
+++ if( start < str.size() )
+++ subStrings.push_back( str.substr( start, str.size()-start ) );
+++ return subStrings;
+++ }
+++
+++ std::ostream& operator << ( std::ostream& os, pluralise const& pluraliser ) {
+++ os << pluraliser.m_count << ' ' << pluraliser.m_label;
+++ if( pluraliser.m_count != 1 )
+++ os << 's';
+++ return os;
+++ }
+++
+++}
+++
+++
+++
+++#include <algorithm>
+++#include <ostream>
+++#include <cstring>
+++#include <cstdint>
+++
+++namespace Catch {
+++ StringRef::StringRef( char const* rawChars ) noexcept
+++ : StringRef( rawChars, std::strlen(rawChars) )
+++ {}
+++
+++
+++ bool StringRef::operator<(StringRef rhs) const noexcept {
+++ if (m_size < rhs.m_size) {
+++ return strncmp(m_start, rhs.m_start, m_size) <= 0;
+++ }
+++ return strncmp(m_start, rhs.m_start, rhs.m_size) < 0;
+++ }
+++
+++ int StringRef::compare( StringRef rhs ) const {
+++ auto cmpResult =
+++ strncmp( m_start, rhs.m_start, std::min( m_size, rhs.m_size ) );
+++
+++ // This means that strncmp found a difference before the strings
+++ // ended, and we can return it directly
+++ if ( cmpResult != 0 ) {
+++ return cmpResult;
+++ }
+++
+++ // If strings are equal up to length, then their comparison results on
+++ // their size
+++ if ( m_size < rhs.m_size ) {
+++ return -1;
+++ } else if ( m_size > rhs.m_size ) {
+++ return 1;
+++ } else {
+++ return 0;
+++ }
+++ }
+++
+++ auto operator << ( std::ostream& os, StringRef str ) -> std::ostream& {
+++ return os.write(str.data(), static_cast<std::streamsize>(str.size()));
+++ }
+++
+++ std::string operator+(StringRef lhs, StringRef rhs) {
+++ std::string ret;
+++ ret.reserve(lhs.size() + rhs.size());
+++ ret += lhs;
+++ ret += rhs;
+++ return ret;
+++ }
+++
+++ auto operator+=( std::string& lhs, StringRef rhs ) -> std::string& {
+++ lhs.append(rhs.data(), rhs.size());
+++ return lhs;
+++ }
+++
+++} // namespace Catch
+++
+++
+++
+++namespace Catch {
+++
+++ TagAliasRegistry::~TagAliasRegistry() = default;
+++
+++ TagAlias const* TagAliasRegistry::find( std::string const& alias ) const {
+++ auto it = m_registry.find( alias );
+++ if( it != m_registry.end() )
+++ return &(it->second);
+++ else
+++ return nullptr;
+++ }
+++
+++ std::string TagAliasRegistry::expandAliases( std::string const& unexpandedTestSpec ) const {
+++ std::string expandedTestSpec = unexpandedTestSpec;
+++ for( auto const& registryKvp : m_registry ) {
+++ std::size_t pos = expandedTestSpec.find( registryKvp.first );
+++ if( pos != std::string::npos ) {
+++ expandedTestSpec = expandedTestSpec.substr( 0, pos ) +
+++ registryKvp.second.tag +
+++ expandedTestSpec.substr( pos + registryKvp.first.size() );
+++ }
+++ }
+++ return expandedTestSpec;
+++ }
+++
+++ void TagAliasRegistry::add( std::string const& alias, std::string const& tag, SourceLineInfo const& lineInfo ) {
+++ CATCH_ENFORCE( startsWith(alias, "[@") && endsWith(alias, ']'),
+++ "error: tag alias, '" << alias << "' is not of the form [@alias name].\n" << lineInfo );
+++
+++ CATCH_ENFORCE( m_registry.insert(std::make_pair(alias, TagAlias(tag, lineInfo))).second,
+++ "error: tag alias, '" << alias << "' already registered.\n"
+++ << "\tFirst seen at: " << find(alias)->lineInfo << "\n"
+++ << "\tRedefined at: " << lineInfo );
+++ }
+++
+++ ITagAliasRegistry::~ITagAliasRegistry() = default;
+++
+++ ITagAliasRegistry const& ITagAliasRegistry::get() {
+++ return getRegistryHub().getTagAliasRegistry();
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++namespace Catch {
+++ TestCaseInfoHasher::TestCaseInfoHasher( hash_t seed ): m_seed( seed ) {}
+++
+++ uint32_t TestCaseInfoHasher::operator()( TestCaseInfo const& t ) const {
+++ // FNV-1a hash algorithm that is designed for uniqueness:
+++ const hash_t prime = 1099511628211u;
+++ hash_t hash = 14695981039346656037u;
+++ for ( const char c : t.name ) {
+++ hash ^= c;
+++ hash *= prime;
+++ }
+++ for ( const char c : t.className ) {
+++ hash ^= c;
+++ hash *= prime;
+++ }
+++ for ( const Tag& tag : t.tags ) {
+++ for ( const char c : tag.original ) {
+++ hash ^= c;
+++ hash *= prime;
+++ }
+++ }
+++ hash ^= m_seed;
+++ hash *= prime;
+++ const uint32_t low{ static_cast<uint32_t>( hash ) };
+++ const uint32_t high{ static_cast<uint32_t>( hash >> 32 ) };
+++ return low * high;
+++ }
+++} // namespace Catch
+++
+++
+++
+++
+++#include <algorithm>
+++#include <set>
+++
+++namespace Catch {
+++
+++ namespace {
+++ static void enforceNoDuplicateTestCases(
+++ std::vector<TestCaseHandle> const& tests ) {
+++ auto testInfoCmp = []( TestCaseInfo const* lhs,
+++ TestCaseInfo const* rhs ) {
+++ return *lhs < *rhs;
+++ };
+++ std::set<TestCaseInfo const*, decltype( testInfoCmp )&> seenTests(
+++ testInfoCmp );
+++ for ( auto const& test : tests ) {
+++ const auto infoPtr = &test.getTestCaseInfo();
+++ const auto prev = seenTests.insert( infoPtr );
+++ CATCH_ENFORCE( prev.second,
+++ "error: test case \""
+++ << infoPtr->name << "\", with tags \""
+++ << infoPtr->tagsAsString()
+++ << "\" already defined.\n"
+++ << "\tFirst seen at "
+++ << ( *prev.first )->lineInfo << "\n"
+++ << "\tRedefined at " << infoPtr->lineInfo );
+++ }
+++ }
+++
+++ static bool matchTest( TestCaseHandle const& testCase,
+++ TestSpec const& testSpec,
+++ IConfig const& config ) {
+++ return testSpec.matches( testCase.getTestCaseInfo() ) &&
+++ isThrowSafe( testCase, config );
+++ }
+++
+++ } // end unnamed namespace
+++
+++ std::vector<TestCaseHandle> sortTests( IConfig const& config, std::vector<TestCaseHandle> const& unsortedTestCases ) {
+++ switch (config.runOrder()) {
+++ case TestRunOrder::Declared:
+++ return unsortedTestCases;
+++
+++ case TestRunOrder::LexicographicallySorted: {
+++ std::vector<TestCaseHandle> sorted = unsortedTestCases;
+++ std::sort(
+++ sorted.begin(),
+++ sorted.end(),
+++ []( TestCaseHandle const& lhs, TestCaseHandle const& rhs ) {
+++ return lhs.getTestCaseInfo() < rhs.getTestCaseInfo();
+++ }
+++ );
+++ return sorted;
+++ }
+++ case TestRunOrder::Randomized: {
+++ using TestWithHash = std::pair<TestCaseInfoHasher::hash_t, TestCaseHandle>;
+++
+++ TestCaseInfoHasher h{ config.rngSeed() };
+++ std::vector<TestWithHash> indexed_tests;
+++ indexed_tests.reserve(unsortedTestCases.size());
+++
+++ for (auto const& handle : unsortedTestCases) {
+++ indexed_tests.emplace_back(h(handle.getTestCaseInfo()), handle);
+++ }
+++
+++ std::sort( indexed_tests.begin(),
+++ indexed_tests.end(),
+++ []( TestWithHash const& lhs, TestWithHash const& rhs ) {
+++ if ( lhs.first == rhs.first ) {
+++ return lhs.second.getTestCaseInfo() <
+++ rhs.second.getTestCaseInfo();
+++ }
+++ return lhs.first < rhs.first;
+++ } );
+++
+++ std::vector<TestCaseHandle> randomized;
+++ randomized.reserve(indexed_tests.size());
+++
+++ for (auto const& indexed : indexed_tests) {
+++ randomized.push_back(indexed.second);
+++ }
+++
+++ return randomized;
+++ }
+++ }
+++
+++ CATCH_INTERNAL_ERROR("Unknown test order value!");
+++ }
+++
+++ bool isThrowSafe( TestCaseHandle const& testCase, IConfig const& config ) {
+++ return !testCase.getTestCaseInfo().throws() || config.allowThrows();
+++ }
+++
+++ std::vector<TestCaseHandle> filterTests( std::vector<TestCaseHandle> const& testCases, TestSpec const& testSpec, IConfig const& config ) {
+++ std::vector<TestCaseHandle> filtered;
+++ filtered.reserve( testCases.size() );
+++ for (auto const& testCase : testCases) {
+++ if ((!testSpec.hasFilters() && !testCase.getTestCaseInfo().isHidden()) ||
+++ (testSpec.hasFilters() && matchTest(testCase, testSpec, config))) {
+++ filtered.push_back(testCase);
+++ }
+++ }
+++ return createShard(filtered, config.shardCount(), config.shardIndex());
+++ }
+++ std::vector<TestCaseHandle> const& getAllTestCasesSorted( IConfig const& config ) {
+++ return getRegistryHub().getTestCaseRegistry().getAllTestsSorted( config );
+++ }
+++
+++ TestRegistry::~TestRegistry() = default;
+++
+++ void TestRegistry::registerTest(Detail::unique_ptr<TestCaseInfo> testInfo, Detail::unique_ptr<ITestInvoker> testInvoker) {
+++ m_handles.emplace_back(testInfo.get(), testInvoker.get());
+++ m_viewed_test_infos.push_back(testInfo.get());
+++ m_owned_test_infos.push_back(CATCH_MOVE(testInfo));
+++ m_invokers.push_back(CATCH_MOVE(testInvoker));
+++ }
+++
+++ std::vector<TestCaseInfo*> const& TestRegistry::getAllInfos() const {
+++ return m_viewed_test_infos;
+++ }
+++
+++ std::vector<TestCaseHandle> const& TestRegistry::getAllTests() const {
+++ return m_handles;
+++ }
+++ std::vector<TestCaseHandle> const& TestRegistry::getAllTestsSorted( IConfig const& config ) const {
+++ if( m_sortedFunctions.empty() )
+++ enforceNoDuplicateTestCases( m_handles );
+++
+++ if( m_currentSortOrder != config.runOrder() || m_sortedFunctions.empty() ) {
+++ m_sortedFunctions = sortTests( config, m_handles );
+++ m_currentSortOrder = config.runOrder();
+++ }
+++ return m_sortedFunctions;
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++#include <algorithm>
+++#include <cassert>
+++
+++#if defined(__clang__)
+++# pragma clang diagnostic push
+++# pragma clang diagnostic ignored "-Wexit-time-destructors"
+++#endif
+++
+++namespace Catch {
+++namespace TestCaseTracking {
+++
+++ NameAndLocation::NameAndLocation( std::string&& _name, SourceLineInfo const& _location )
+++ : name( CATCH_MOVE(_name) ),
+++ location( _location )
+++ {}
+++
+++
+++ ITracker::~ITracker() = default;
+++
+++ void ITracker::markAsNeedingAnotherRun() {
+++ m_runState = NeedsAnotherRun;
+++ }
+++
+++ void ITracker::addChild( ITrackerPtr&& child ) {
+++ m_children.push_back( CATCH_MOVE(child) );
+++ }
+++
+++ ITracker* ITracker::findChild( NameAndLocationRef const& nameAndLocation ) {
+++ auto it = std::find_if(
+++ m_children.begin(),
+++ m_children.end(),
+++ [&nameAndLocation]( ITrackerPtr const& tracker ) {
+++ auto const& tnameAndLoc = tracker->nameAndLocation();
+++ if ( tnameAndLoc.location.line !=
+++ nameAndLocation.location.line ) {
+++ return false;
+++ }
+++ return tnameAndLoc == nameAndLocation;
+++ } );
+++ return ( it != m_children.end() ) ? it->get() : nullptr;
+++ }
+++
+++ bool ITracker::isSectionTracker() const { return false; }
+++ bool ITracker::isGeneratorTracker() const { return false; }
+++
+++ bool ITracker::isOpen() const {
+++ return m_runState != NotStarted && !isComplete();
+++ }
+++
+++ bool ITracker::hasStarted() const { return m_runState != NotStarted; }
+++
+++ void ITracker::openChild() {
+++ if (m_runState != ExecutingChildren) {
+++ m_runState = ExecutingChildren;
+++ if (m_parent) {
+++ m_parent->openChild();
+++ }
+++ }
+++ }
+++
+++ ITracker& TrackerContext::startRun() {
+++ using namespace std::string_literals;
+++ m_rootTracker = Catch::Detail::make_unique<SectionTracker>(
+++ NameAndLocation( "{root}"s, CATCH_INTERNAL_LINEINFO ),
+++ *this,
+++ nullptr );
+++ m_currentTracker = nullptr;
+++ m_runState = Executing;
+++ return *m_rootTracker;
+++ }
+++
+++ void TrackerContext::completeCycle() {
+++ m_runState = CompletedCycle;
+++ }
+++
+++ bool TrackerContext::completedCycle() const {
+++ return m_runState == CompletedCycle;
+++ }
+++ void TrackerContext::setCurrentTracker( ITracker* tracker ) {
+++ m_currentTracker = tracker;
+++ }
+++
+++
+++ TrackerBase::TrackerBase( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent ):
+++ ITracker(CATCH_MOVE(nameAndLocation), parent),
+++ m_ctx( ctx )
+++ {}
+++
+++ bool TrackerBase::isComplete() const {
+++ return m_runState == CompletedSuccessfully || m_runState == Failed;
+++ }
+++
+++ void TrackerBase::open() {
+++ m_runState = Executing;
+++ moveToThis();
+++ if( m_parent )
+++ m_parent->openChild();
+++ }
+++
+++ void TrackerBase::close() {
+++
+++ // Close any still open children (e.g. generators)
+++ while( &m_ctx.currentTracker() != this )
+++ m_ctx.currentTracker().close();
+++
+++ switch( m_runState ) {
+++ case NeedsAnotherRun:
+++ break;
+++
+++ case Executing:
+++ m_runState = CompletedSuccessfully;
+++ break;
+++ case ExecutingChildren:
+++ if( std::all_of(m_children.begin(), m_children.end(), [](ITrackerPtr const& t){ return t->isComplete(); }) )
+++ m_runState = CompletedSuccessfully;
+++ break;
+++
+++ case NotStarted:
+++ case CompletedSuccessfully:
+++ case Failed:
+++ CATCH_INTERNAL_ERROR( "Illogical state: " << m_runState );
+++
+++ default:
+++ CATCH_INTERNAL_ERROR( "Unknown state: " << m_runState );
+++ }
+++ moveToParent();
+++ m_ctx.completeCycle();
+++ }
+++ void TrackerBase::fail() {
+++ m_runState = Failed;
+++ if( m_parent )
+++ m_parent->markAsNeedingAnotherRun();
+++ moveToParent();
+++ m_ctx.completeCycle();
+++ }
+++
+++ void TrackerBase::moveToParent() {
+++ assert( m_parent );
+++ m_ctx.setCurrentTracker( m_parent );
+++ }
+++ void TrackerBase::moveToThis() {
+++ m_ctx.setCurrentTracker( this );
+++ }
+++
+++ SectionTracker::SectionTracker( NameAndLocation&& nameAndLocation, TrackerContext& ctx, ITracker* parent )
+++ : TrackerBase( CATCH_MOVE(nameAndLocation), ctx, parent ),
+++ m_trimmed_name(trim(StringRef(ITracker::nameAndLocation().name)))
+++ {
+++ if( parent ) {
+++ while ( !parent->isSectionTracker() ) {
+++ parent = parent->parent();
+++ }
+++
+++ SectionTracker& parentSection = static_cast<SectionTracker&>( *parent );
+++ addNextFilters( parentSection.m_filters );
+++ }
+++ }
+++
+++ bool SectionTracker::isComplete() const {
+++ bool complete = true;
+++
+++ if (m_filters.empty()
+++ || m_filters[0].empty()
+++ || std::find(m_filters.begin(), m_filters.end(), m_trimmed_name) != m_filters.end()) {
+++ complete = TrackerBase::isComplete();
+++ }
+++ return complete;
+++ }
+++
+++ bool SectionTracker::isSectionTracker() const { return true; }
+++
+++ SectionTracker& SectionTracker::acquire( TrackerContext& ctx, NameAndLocationRef const& nameAndLocation ) {
+++ SectionTracker* tracker;
+++
+++ ITracker& currentTracker = ctx.currentTracker();
+++ if ( ITracker* childTracker =
+++ currentTracker.findChild( nameAndLocation ) ) {
+++ assert( childTracker );
+++ assert( childTracker->isSectionTracker() );
+++ tracker = static_cast<SectionTracker*>( childTracker );
+++ } else {
+++ auto newTracker = Catch::Detail::make_unique<SectionTracker>(
+++ NameAndLocation{ static_cast<std::string>(nameAndLocation.name),
+++ nameAndLocation.location },
+++ ctx,
+++ ¤tTracker );
+++ tracker = newTracker.get();
+++ currentTracker.addChild( CATCH_MOVE( newTracker ) );
+++ }
+++
+++ if ( !ctx.completedCycle() ) {
+++ tracker->tryOpen();
+++ }
+++
+++ return *tracker;
+++ }
+++
+++ void SectionTracker::tryOpen() {
+++ if( !isComplete() )
+++ open();
+++ }
+++
+++ void SectionTracker::addInitialFilters( std::vector<std::string> const& filters ) {
+++ if( !filters.empty() ) {
+++ m_filters.reserve( m_filters.size() + filters.size() + 2 );
+++ m_filters.emplace_back(StringRef{}); // Root - should never be consulted
+++ m_filters.emplace_back(StringRef{}); // Test Case - not a section filter
+++ m_filters.insert( m_filters.end(), filters.begin(), filters.end() );
+++ }
+++ }
+++ void SectionTracker::addNextFilters( std::vector<StringRef> const& filters ) {
+++ if( filters.size() > 1 )
+++ m_filters.insert( m_filters.end(), filters.begin()+1, filters.end() );
+++ }
+++
+++ StringRef SectionTracker::trimmedName() const {
+++ return m_trimmed_name;
+++ }
+++
+++} // namespace TestCaseTracking
+++
+++} // namespace Catch
+++
+++#if defined(__clang__)
+++# pragma clang diagnostic pop
+++#endif
+++
+++
+++
+++
+++namespace Catch {
+++
+++ void throw_test_failure_exception() {
+++#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
+++ throw TestFailureException{};
+++#else
+++ CATCH_ERROR( "Test failure requires aborting test!" );
+++#endif
+++ }
+++
+++ void throw_test_skip_exception() {
+++#if !defined( CATCH_CONFIG_DISABLE_EXCEPTIONS )
+++ throw Catch::TestSkipException();
+++#else
+++ CATCH_ERROR( "Explicitly skipping tests during runtime requires exceptions" );
+++#endif
+++ }
+++
+++} // namespace Catch
+++
+++
+++
+++#include <algorithm>
+++#include <iterator>
+++
+++namespace Catch {
+++ ITestInvoker::~ITestInvoker() = default;
+++
+++ namespace {
+++ static StringRef extractClassName( StringRef classOrMethodName ) {
+++ if ( !startsWith( classOrMethodName, '&' ) ) {
+++ return classOrMethodName;
+++ }
+++
+++ // Remove the leading '&' to avoid having to special case it later
+++ const auto methodName =
+++ classOrMethodName.substr( 1, classOrMethodName.size() );
+++
+++ auto reverseStart = std::make_reverse_iterator( methodName.end() );
+++ auto reverseEnd = std::make_reverse_iterator( methodName.begin() );
+++
+++ // We make a simplifying assumption that ":" is only present
+++ // in the input as part of "::" from C++ typenames (this is
+++ // relatively safe assumption because the input is generated
+++ // as stringification of type through preprocessor).
+++ auto lastColons = std::find( reverseStart, reverseEnd, ':' ) + 1;
+++ auto secondLastColons =
+++ std::find( lastColons + 1, reverseEnd, ':' );
+++
+++ auto const startIdx = reverseEnd - secondLastColons;
+++ auto const classNameSize = secondLastColons - lastColons - 1;
+++
+++ return methodName.substr(
+++ static_cast<std::size_t>( startIdx ),
+++ static_cast<std::size_t>( classNameSize ) );
+++ }
+++
+++ class TestInvokerAsFunction final : public ITestInvoker {
+++ using TestType = void ( * )();
+++ TestType m_testAsFunction;
+++
+++ public:
+++ TestInvokerAsFunction( TestType testAsFunction ) noexcept:
+++ m_testAsFunction( testAsFunction ) {}
+++
+++ void invoke() const override { m_testAsFunction(); }
+++ };
+++
+++ } // namespace
+++
+++ Detail::unique_ptr<ITestInvoker> makeTestInvoker( void(*testAsFunction)() ) {
+++ return Detail::make_unique<TestInvokerAsFunction>( testAsFunction );
+++ }
+++
+++ AutoReg::AutoReg( Detail::unique_ptr<ITestInvoker> invoker, SourceLineInfo const& lineInfo, StringRef classOrMethod, NameAndTags const& nameAndTags ) noexcept {
+++ CATCH_TRY {
+++ getMutableRegistryHub()
+++ .registerTest(
+++ makeTestCaseInfo(
+++ extractClassName( classOrMethod ),
+++ nameAndTags,
+++ lineInfo),
+++ CATCH_MOVE(invoker)
+++ );
+++ } CATCH_CATCH_ALL {
+++ // Do not throw when constructing global objects, instead register the exception to be processed later
+++ getMutableRegistryHub().registerStartupException();
+++ }
+++ }
+++}
+++
+++
+++
+++
+++
+++namespace Catch {
+++
+++ TestSpecParser::TestSpecParser( ITagAliasRegistry const& tagAliases ) : m_tagAliases( &tagAliases ) {}
+++
+++ TestSpecParser& TestSpecParser::parse( std::string const& arg ) {
+++ m_mode = None;
+++ m_exclusion = false;
+++ m_arg = m_tagAliases->expandAliases( arg );
+++ m_escapeChars.clear();
+++ m_substring.reserve(m_arg.size());
+++ m_patternName.reserve(m_arg.size());
+++ m_realPatternPos = 0;
+++
+++ for( m_pos = 0; m_pos < m_arg.size(); ++m_pos )
+++ //if visitChar fails
+++ if( !visitChar( m_arg[m_pos] ) ){
+++ m_testSpec.m_invalidSpecs.push_back(arg);
+++ break;
+++ }
+++ endMode();
+++ return *this;
+++ }
+++ TestSpec TestSpecParser::testSpec() {
+++ addFilter();
+++ return CATCH_MOVE(m_testSpec);
+++ }
+++ bool TestSpecParser::visitChar( char c ) {
+++ if( (m_mode != EscapedName) && (c == '\\') ) {
+++ escape();
+++ addCharToPattern(c);
+++ return true;
+++ }else if((m_mode != EscapedName) && (c == ',') ) {
+++ return separate();
+++ }
+++
+++ switch( m_mode ) {
+++ case None:
+++ if( processNoneChar( c ) )
+++ return true;
+++ break;
+++ case Name:
+++ processNameChar( c );
+++ break;
+++ case EscapedName:
+++ endMode();
+++ addCharToPattern(c);
+++ return true;
+++ default:
+++ case Tag:
+++ case QuotedName:
+++ if( processOtherChar( c ) )
+++ return true;
+++ break;
+++ }
+++
+++ m_substring += c;
+++ if( !isControlChar( c ) ) {
+++ m_patternName += c;
+++ m_realPatternPos++;
+++ }
+++ return true;
+++ }
+++ // Two of the processing methods return true to signal the caller to return
+++ // without adding the given character to the current pattern strings
+++ bool TestSpecParser::processNoneChar( char c ) {
+++ switch( c ) {
+++ case ' ':
+++ return true;
+++ case '~':
+++ m_exclusion = true;
+++ return false;
+++ case '[':
+++ startNewMode( Tag );
+++ return false;
+++ case '"':
+++ startNewMode( QuotedName );
+++ return false;
+++ default:
+++ startNewMode( Name );
+++ return false;
+++ }
+++ }
+++ void TestSpecParser::processNameChar( char c ) {
+++ if( c == '[' ) {
+++ if( m_substring == "exclude:" )
+++ m_exclusion = true;
+++ else
+++ endMode();
+++ startNewMode( Tag );
+++ }
+++ }
+++ bool TestSpecParser::processOtherChar( char c ) {
+++ if( !isControlChar( c ) )
+++ return false;
+++ m_substring += c;
+++ endMode();
+++ return true;
+++ }
+++ void TestSpecParser::startNewMode( Mode mode ) {
+++ m_mode = mode;
+++ }
+++ void TestSpecParser::endMode() {
+++ switch( m_mode ) {
+++ case Name:
+++ case QuotedName:
+++ return addNamePattern();
+++ case Tag:
+++ return addTagPattern();
+++ case EscapedName:
+++ revertBackToLastMode();
+++ return;
+++ case None:
+++ default:
+++ return startNewMode( None );
+++ }
+++ }
+++ void TestSpecParser::escape() {
+++ saveLastMode();
+++ m_mode = EscapedName;
+++ m_escapeChars.push_back(m_realPatternPos);
+++ }
+++ bool TestSpecParser::isControlChar( char c ) const {
+++ switch( m_mode ) {
+++ default:
+++ return false;
+++ case None:
+++ return c == '~';
+++ case Name:
+++ return c == '[';
+++ case EscapedName:
+++ return true;
+++ case QuotedName:
+++ return c == '"';
+++ case Tag:
+++ return c == '[' || c == ']';
+++ }
+++ }
+++
+++ void TestSpecParser::addFilter() {
+++ if( !m_currentFilter.m_required.empty() || !m_currentFilter.m_forbidden.empty() ) {
+++ m_testSpec.m_filters.push_back( CATCH_MOVE(m_currentFilter) );
+++ m_currentFilter = TestSpec::Filter();
+++ }
+++ }
+++
+++ void TestSpecParser::saveLastMode() {
+++ lastMode = m_mode;
+++ }
+++
+++ void TestSpecParser::revertBackToLastMode() {
+++ m_mode = lastMode;
+++ }
+++
+++ bool TestSpecParser::separate() {
+++ if( (m_mode==QuotedName) || (m_mode==Tag) ){
+++ //invalid argument, signal failure to previous scope.
+++ m_mode = None;
+++ m_pos = m_arg.size();
+++ m_substring.clear();
+++ m_patternName.clear();
+++ m_realPatternPos = 0;
+++ return false;
+++ }
+++ endMode();
+++ addFilter();
+++ return true; //success
+++ }
+++
+++ std::string TestSpecParser::preprocessPattern() {
+++ std::string token = m_patternName;
+++ for (std::size_t i = 0; i < m_escapeChars.size(); ++i)
+++ token = token.substr(0, m_escapeChars[i] - i) + token.substr(m_escapeChars[i] - i + 1);
+++ m_escapeChars.clear();
+++ if (startsWith(token, "exclude:")) {
+++ m_exclusion = true;
+++ token = token.substr(8);
+++ }
+++
+++ m_patternName.clear();
+++ m_realPatternPos = 0;
+++
+++ return token;
+++ }
+++
+++ void TestSpecParser::addNamePattern() {
+++ auto token = preprocessPattern();
+++
+++ if (!token.empty()) {
+++ if (m_exclusion) {
+++ m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::NamePattern>(token, m_substring));
+++ } else {
+++ m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::NamePattern>(token, m_substring));
+++ }
+++ }
+++ m_substring.clear();
+++ m_exclusion = false;
+++ m_mode = None;
+++ }
+++
+++ void TestSpecParser::addTagPattern() {
+++ auto token = preprocessPattern();
+++
+++ if (!token.empty()) {
+++ // If the tag pattern is the "hide and tag" shorthand (e.g. [.foo])
+++ // we have to create a separate hide tag and shorten the real one
+++ if (token.size() > 1 && token[0] == '.') {
+++ token.erase(token.begin());
+++ if (m_exclusion) {
+++ m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
+++ } else {
+++ m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(".", m_substring));
+++ }
+++ }
+++ if (m_exclusion) {
+++ m_currentFilter.m_forbidden.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
+++ } else {
+++ m_currentFilter.m_required.emplace_back(Detail::make_unique<TestSpec::TagPattern>(token, m_substring));
+++ }
+++ }
+++ m_substring.clear();
+++ m_exclusion = false;
+++ m_mode = None;
+++ }
+++
+++} // namespace Catch
+++
+++
+++
+++#include <algorithm>
+++#include <cstring>
+++#include <ostream>
+++
+++namespace {
+++ bool isWhitespace( char c ) {
+++ return c == ' ' || c == '\t' || c == '\n' || c == '\r';
+++ }
+++
+++ bool isBreakableBefore( char c ) {
+++ static const char chars[] = "[({<|";
+++ return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
+++ }
+++
+++ bool isBreakableAfter( char c ) {
+++ static const char chars[] = "])}>.,:;*+-=&/\\";
+++ return std::memchr( chars, c, sizeof( chars ) - 1 ) != nullptr;
+++ }
+++
+++} // namespace
+++
+++namespace Catch {
+++ namespace TextFlow {
+++ void AnsiSkippingString::preprocessString() {
+++ for ( auto it = m_string.begin(); it != m_string.end(); ) {
+++ // try to read through an ansi sequence
+++ while ( it != m_string.end() && *it == '\033' &&
+++ it + 1 != m_string.end() && *( it + 1 ) == '[' ) {
+++ auto cursor = it + 2;
+++ while ( cursor != m_string.end() &&
+++ ( isdigit( *cursor ) || *cursor == ';' ) ) {
+++ ++cursor;
+++ }
+++ if ( cursor == m_string.end() || *cursor != 'm' ) {
+++ break;
+++ }
+++ // 'm' -> 0xff
+++ *cursor = AnsiSkippingString::sentinel;
+++ // if we've read an ansi sequence, set the iterator and
+++ // return to the top of the loop
+++ it = cursor + 1;
+++ }
+++ if ( it != m_string.end() ) {
+++ ++m_size;
+++ ++it;
+++ }
+++ }
+++ }
+++
+++ AnsiSkippingString::AnsiSkippingString( std::string const& text ):
+++ m_string( text ) {
+++ preprocessString();
+++ }
+++
+++ AnsiSkippingString::AnsiSkippingString( std::string&& text ):
+++ m_string( CATCH_MOVE( text ) ) {
+++ preprocessString();
+++ }
+++
+++ AnsiSkippingString::const_iterator AnsiSkippingString::begin() const {
+++ return const_iterator( m_string );
+++ }
+++
+++ AnsiSkippingString::const_iterator AnsiSkippingString::end() const {
+++ return const_iterator( m_string, const_iterator::EndTag{} );
+++ }
+++
+++ std::string AnsiSkippingString::substring( const_iterator begin,
+++ const_iterator end ) const {
+++ // There's one caveat here to an otherwise simple substring: when
+++ // making a begin iterator we might have skipped ansi sequences at
+++ // the start. If `begin` here is a begin iterator, skipped over
+++ // initial ansi sequences, we'll use the true beginning of the
+++ // string. Lastly: We need to transform any chars we replaced with
+++ // 0xff back to 'm'
+++ auto str = std::string( begin == this->begin() ? m_string.begin()
+++ : begin.m_it,
+++ end.m_it );
+++ std::transform( str.begin(), str.end(), str.begin(), []( char c ) {
+++ return c == AnsiSkippingString::sentinel ? 'm' : c;
+++ } );
+++ return str;
+++ }
+++
+++ void AnsiSkippingString::const_iterator::tryParseAnsiEscapes() {
+++ // check if we've landed on an ansi sequence, and if so read through
+++ // it
+++ while ( m_it != m_string->end() && *m_it == '\033' &&
+++ m_it + 1 != m_string->end() && *( m_it + 1 ) == '[' ) {
+++ auto cursor = m_it + 2;
+++ while ( cursor != m_string->end() &&
+++ ( isdigit( *cursor ) || *cursor == ';' ) ) {
+++ ++cursor;
+++ }
+++ if ( cursor == m_string->end() ||
+++ *cursor != AnsiSkippingString::sentinel ) {
+++ break;
+++ }
+++ // if we've read an ansi sequence, set the iterator and
+++ // return to the top of the loop
+++ m_it = cursor + 1;
+++ }
+++ }
+++
+++ void AnsiSkippingString::const_iterator::advance() {
+++ assert( m_it != m_string->end() );
+++ m_it++;
+++ tryParseAnsiEscapes();
+++ }
+++
+++ void AnsiSkippingString::const_iterator::unadvance() {
+++ assert( m_it != m_string->begin() );
+++ m_it--;
+++ // if *m_it is 0xff, scan back to the \033 and then m_it-- once more
+++ // (and repeat check)
+++ while ( *m_it == AnsiSkippingString::sentinel ) {
+++ while ( *m_it != '\033' ) {
+++ assert( m_it != m_string->begin() );
+++ m_it--;
+++ }
+++ // if this happens, we must have been a begin iterator that had
+++ // skipped over ansi sequences at the start of a string
+++ assert( m_it != m_string->begin() );
+++ assert( *m_it == '\033' );
+++ m_it--;
+++ }
+++ }
+++
+++ static bool isBoundary( AnsiSkippingString const& line,
+++ AnsiSkippingString::const_iterator it ) {
+++ return it == line.end() ||
+++ ( isWhitespace( *it ) &&
+++ !isWhitespace( *it.oneBefore() ) ) ||
+++ isBreakableBefore( *it ) ||
+++ isBreakableAfter( *it.oneBefore() );
+++ }
+++
+++ void Column::const_iterator::calcLength() {
+++ m_addHyphen = false;
+++ m_parsedTo = m_lineStart;
+++ AnsiSkippingString const& current_line = m_column.m_string;
+++
+++ if ( m_parsedTo == current_line.end() ) {
+++ m_lineEnd = m_parsedTo;
+++ return;
+++ }
+++
+++ assert( m_lineStart != current_line.end() );
+++ if ( *m_lineStart == '\n' ) { ++m_parsedTo; }
+++
+++ const auto maxLineLength = m_column.m_width - indentSize();
+++ std::size_t lineLength = 0;
+++ while ( m_parsedTo != current_line.end() &&
+++ lineLength < maxLineLength && *m_parsedTo != '\n' ) {
+++ ++m_parsedTo;
+++ ++lineLength;
+++ }
+++
+++ // If we encountered a newline before the column is filled,
+++ // then we linebreak at the newline and consider this line
+++ // finished.
+++ if ( lineLength < maxLineLength ) {
+++ m_lineEnd = m_parsedTo;
+++ } else {
+++ // Look for a natural linebreak boundary in the column
+++ // (We look from the end, so that the first found boundary is
+++ // the right one)
+++ m_lineEnd = m_parsedTo;
+++ while ( lineLength > 0 &&
+++ !isBoundary( current_line, m_lineEnd ) ) {
+++ --lineLength;
+++ --m_lineEnd;
+++ }
+++ while ( lineLength > 0 &&
+++ isWhitespace( *m_lineEnd.oneBefore() ) ) {
+++ --lineLength;
+++ --m_lineEnd;
+++ }
+++
+++ // If we found one, then that is where we linebreak, otherwise
+++ // we have to split text with a hyphen
+++ if ( lineLength == 0 ) {
+++ m_addHyphen = true;
+++ m_lineEnd = m_parsedTo.oneBefore();
+++ }
+++ }
+++ }
+++
+++ size_t Column::const_iterator::indentSize() const {
+++ auto initial = m_lineStart == m_column.m_string.begin()
+++ ? m_column.m_initialIndent
+++ : std::string::npos;
+++ return initial == std::string::npos ? m_column.m_indent : initial;
+++ }
+++
+++ std::string Column::const_iterator::addIndentAndSuffix(
+++ AnsiSkippingString::const_iterator start,
+++ AnsiSkippingString::const_iterator end ) const {
+++ std::string ret;
+++ const auto desired_indent = indentSize();
+++ // ret.reserve( desired_indent + (end - start) + m_addHyphen );
+++ ret.append( desired_indent, ' ' );
+++ // ret.append( start, end );
+++ ret += m_column.m_string.substring( start, end );
+++ if ( m_addHyphen ) { ret.push_back( '-' ); }
+++
+++ return ret;
+++ }
+++
+++ Column::const_iterator::const_iterator( Column const& column ):
+++ m_column( column ),
+++ m_lineStart( column.m_string.begin() ),
+++ m_lineEnd( column.m_string.begin() ),
+++ m_parsedTo( column.m_string.begin() ) {
+++ assert( m_column.m_width > m_column.m_indent );
+++ assert( m_column.m_initialIndent == std::string::npos ||
+++ m_column.m_width > m_column.m_initialIndent );
+++ calcLength();
+++ if ( m_lineStart == m_lineEnd ) {
+++ m_lineStart = m_column.m_string.end();
+++ }
+++ }
+++
+++ std::string Column::const_iterator::operator*() const {
+++ assert( m_lineStart <= m_parsedTo );
+++ return addIndentAndSuffix( m_lineStart, m_lineEnd );
+++ }
+++
+++ Column::const_iterator& Column::const_iterator::operator++() {
+++ m_lineStart = m_lineEnd;
+++ AnsiSkippingString const& current_line = m_column.m_string;
+++ if ( m_lineStart != current_line.end() && *m_lineStart == '\n' ) {
+++ m_lineStart++;
+++ } else {
+++ while ( m_lineStart != current_line.end() &&
+++ isWhitespace( *m_lineStart ) ) {
+++ ++m_lineStart;
+++ }
+++ }
+++
+++ if ( m_lineStart != current_line.end() ) { calcLength(); }
+++ return *this;
+++ }
+++
+++ Column::const_iterator Column::const_iterator::operator++( int ) {
+++ const_iterator prev( *this );
+++ operator++();
+++ return prev;
+++ }
+++
+++ std::ostream& operator<<( std::ostream& os, Column const& col ) {
+++ bool first = true;
+++ for ( auto line : col ) {
+++ if ( first ) {
+++ first = false;
+++ } else {
+++ os << '\n';
+++ }
+++ os << line;
+++ }
+++ return os;
+++ }
+++
+++ Column Spacer( size_t spaceWidth ) {
+++ Column ret{ "" };
+++ ret.width( spaceWidth );
+++ return ret;
+++ }
+++
+++ Columns::iterator::iterator( Columns const& columns, EndTag ):
+++ m_columns( columns.m_columns ), m_activeIterators( 0 ) {
+++
+++ m_iterators.reserve( m_columns.size() );
+++ for ( auto const& col : m_columns ) {
+++ m_iterators.push_back( col.end() );
+++ }
+++ }
+++
+++ Columns::iterator::iterator( Columns const& columns ):
+++ m_columns( columns.m_columns ),
+++ m_activeIterators( m_columns.size() ) {
+++
+++ m_iterators.reserve( m_columns.size() );
+++ for ( auto const& col : m_columns ) {
+++ m_iterators.push_back( col.begin() );
+++ }
+++ }
+++
+++ std::string Columns::iterator::operator*() const {
+++ std::string row, padding;
+++
+++ for ( size_t i = 0; i < m_columns.size(); ++i ) {
+++ const auto width = m_columns[i].width();
+++ if ( m_iterators[i] != m_columns[i].end() ) {
+++ std::string col = *m_iterators[i];
+++ row += padding;
+++ row += col;
+++
+++ padding.clear();
+++ if ( col.size() < width ) {
+++ padding.append( width - col.size(), ' ' );
+++ }
+++ } else {
+++ padding.append( width, ' ' );
+++ }
+++ }
+++ return row;
+++ }
+++
+++ Columns::iterator& Columns::iterator::operator++() {
+++ for ( size_t i = 0; i < m_columns.size(); ++i ) {
+++ if ( m_iterators[i] != m_columns[i].end() ) {
+++ ++m_iterators[i];
+++ }
+++ }
+++ return *this;
+++ }
+++
+++ Columns::iterator Columns::iterator::operator++( int ) {
+++ iterator prev( *this );
+++ operator++();
+++ return prev;
+++ }
+++
+++ std::ostream& operator<<( std::ostream& os, Columns const& cols ) {
+++ bool first = true;
+++ for ( auto line : cols ) {
+++ if ( first ) {
+++ first = false;
+++ } else {
+++ os << '\n';
+++ }
+++ os << line;
+++ }
+++ return os;
+++ }
+++
+++ Columns operator+( Column const& lhs, Column const& rhs ) {
+++ Columns cols;
+++ cols += lhs;
+++ cols += rhs;
+++ return cols;
+++ }
+++ Columns operator+( Column&& lhs, Column&& rhs ) {
+++ Columns cols;
+++ cols += CATCH_MOVE( lhs );
+++ cols += CATCH_MOVE( rhs );
+++ return cols;
+++ }
+++
+++ Columns& operator+=( Columns& lhs, Column const& rhs ) {
+++ lhs.m_columns.push_back( rhs );
+++ return lhs;
+++ }
+++ Columns& operator+=( Columns& lhs, Column&& rhs ) {
+++ lhs.m_columns.push_back( CATCH_MOVE( rhs ) );
+++ return lhs;
+++ }
+++ Columns operator+( Columns const& lhs, Column const& rhs ) {
+++ auto combined( lhs );
+++ combined += rhs;
+++ return combined;
+++ }
+++ Columns operator+( Columns&& lhs, Column&& rhs ) {
+++ lhs += CATCH_MOVE( rhs );
+++ return CATCH_MOVE( lhs );
+++ }
+++
+++ } // namespace TextFlow
+++} // namespace Catch
+++
+++
+++
+++
+++#include <exception>
+++
+++namespace Catch {
+++ bool uncaught_exceptions() {
+++#if defined(CATCH_CONFIG_DISABLE_EXCEPTIONS)
+++ return false;
+++#elif defined(CATCH_CONFIG_CPP17_UNCAUGHT_EXCEPTIONS)
+++ return std::uncaught_exceptions() > 0;
+++#else
+++ return std::uncaught_exception();
+++#endif
+++ }
+++} // end namespace Catch
+++
+++
+++
+++namespace Catch {
+++
+++ WildcardPattern::WildcardPattern( std::string const& pattern,
+++ CaseSensitive caseSensitivity )
+++ : m_caseSensitivity( caseSensitivity ),
+++ m_pattern( normaliseString( pattern ) )
+++ {
+++ if( startsWith( m_pattern, '*' ) ) {
+++ m_pattern = m_pattern.substr( 1 );
+++ m_wildcard = WildcardAtStart;
+++ }
+++ if( endsWith( m_pattern, '*' ) ) {
+++ m_pattern = m_pattern.substr( 0, m_pattern.size()-1 );
+++ m_wildcard = static_cast<WildcardPosition>( m_wildcard | WildcardAtEnd );
+++ }
+++ }
+++
+++ bool WildcardPattern::matches( std::string const& str ) const {
+++ switch( m_wildcard ) {
+++ case NoWildcard:
+++ return m_pattern == normaliseString( str );
+++ case WildcardAtStart:
+++ return endsWith( normaliseString( str ), m_pattern );
+++ case WildcardAtEnd:
+++ return startsWith( normaliseString( str ), m_pattern );
+++ case WildcardAtBothEnds:
+++ return contains( normaliseString( str ), m_pattern );
+++ default:
+++ CATCH_INTERNAL_ERROR( "Unknown enum" );
+++ }
+++ }
+++
+++ std::string WildcardPattern::normaliseString( std::string const& str ) const {
+++ return trim( m_caseSensitivity == CaseSensitive::No ? toLower( str ) : str );
+++ }
+++}
+++
+++
+++// Note: swapping these two includes around causes MSVC to error out
+++// while in /permissive- mode. No, I don't know why.
+++// Tested on VS 2019, 18.{3, 4}.x
+++
+++#include <cstdint>
+++#include <iomanip>
+++#include <type_traits>
+++
+++namespace Catch {
+++
+++namespace {
+++
+++ size_t trailingBytes(unsigned char c) {
+++ if ((c & 0xE0) == 0xC0) {
+++ return 2;
+++ }
+++ if ((c & 0xF0) == 0xE0) {
+++ return 3;
+++ }
+++ if ((c & 0xF8) == 0xF0) {
+++ return 4;
+++ }
+++ CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+++ }
+++
+++ uint32_t headerValue(unsigned char c) {
+++ if ((c & 0xE0) == 0xC0) {
+++ return c & 0x1F;
+++ }
+++ if ((c & 0xF0) == 0xE0) {
+++ return c & 0x0F;
+++ }
+++ if ((c & 0xF8) == 0xF0) {
+++ return c & 0x07;
+++ }
+++ CATCH_INTERNAL_ERROR("Invalid multibyte utf-8 start byte encountered");
+++ }
+++
+++ void hexEscapeChar(std::ostream& os, unsigned char c) {
+++ std::ios_base::fmtflags f(os.flags());
+++ os << "\\x"
+++ << std::uppercase << std::hex << std::setfill('0') << std::setw(2)
+++ << static_cast<int>(c);
+++ os.flags(f);
+++ }
+++
+++ bool shouldNewline(XmlFormatting fmt) {
+++ return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Newline));
+++ }
+++
+++ bool shouldIndent(XmlFormatting fmt) {
+++ return !!(static_cast<std::underlying_type_t<XmlFormatting>>(fmt & XmlFormatting::Indent));
+++ }
+++
+++} // anonymous namespace
+++
+++ XmlFormatting operator | (XmlFormatting lhs, XmlFormatting rhs) {
+++ return static_cast<XmlFormatting>(
+++ static_cast<std::underlying_type_t<XmlFormatting>>(lhs) |
+++ static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
+++ );
+++ }
+++
+++ XmlFormatting operator & (XmlFormatting lhs, XmlFormatting rhs) {
+++ return static_cast<XmlFormatting>(
+++ static_cast<std::underlying_type_t<XmlFormatting>>(lhs) &
+++ static_cast<std::underlying_type_t<XmlFormatting>>(rhs)
+++ );
+++ }
+++
+++
+++ XmlEncode::XmlEncode( StringRef str, ForWhat forWhat )
+++ : m_str( str ),
+++ m_forWhat( forWhat )
+++ {}
+++
+++ void XmlEncode::encodeTo( std::ostream& os ) const {
+++ // Apostrophe escaping not necessary if we always use " to write attributes
+++ // (see: http://www.w3.org/TR/xml/#syntax)
+++
+++ for( std::size_t idx = 0; idx < m_str.size(); ++ idx ) {
+++ unsigned char c = static_cast<unsigned char>(m_str[idx]);
+++ switch (c) {
+++ case '<': os << "<"; break;
+++ case '&': os << "&"; break;
+++
+++ case '>':
+++ // See: http://www.w3.org/TR/xml/#syntax
+++ if (idx > 2 && m_str[idx - 1] == ']' && m_str[idx - 2] == ']')
+++ os << ">";
+++ else
+++ os << c;
+++ break;
+++
+++ case '\"':
+++ if (m_forWhat == ForAttributes)
+++ os << """;
+++ else
+++ os << c;
+++ break;
+++
+++ default:
+++ // Check for control characters and invalid utf-8
+++
+++ // Escape control characters in standard ascii
+++ // see http://stackoverflow.com/questions/404107/why-are-control-characters-illegal-in-xml-1-0
+++ if (c < 0x09 || (c > 0x0D && c < 0x20) || c == 0x7F) {
+++ hexEscapeChar(os, c);
+++ break;
+++ }
+++
+++ // Plain ASCII: Write it to stream
+++ if (c < 0x7F) {
+++ os << c;
+++ break;
+++ }
+++
+++ // UTF-8 territory
+++ // Check if the encoding is valid and if it is not, hex escape bytes.
+++ // Important: We do not check the exact decoded values for validity, only the encoding format
+++ // First check that this bytes is a valid lead byte:
+++ // This means that it is not encoded as 1111 1XXX
+++ // Or as 10XX XXXX
+++ if (c < 0xC0 ||
+++ c >= 0xF8) {
+++ hexEscapeChar(os, c);
+++ break;
+++ }
+++
+++ auto encBytes = trailingBytes(c);
+++ // Are there enough bytes left to avoid accessing out-of-bounds memory?
+++ if (idx + encBytes - 1 >= m_str.size()) {
+++ hexEscapeChar(os, c);
+++ break;
+++ }
+++ // The header is valid, check data
+++ // The next encBytes bytes must together be a valid utf-8
+++ // This means: bitpattern 10XX XXXX and the extracted value is sane (ish)
+++ bool valid = true;
+++ uint32_t value = headerValue(c);
+++ for (std::size_t n = 1; n < encBytes; ++n) {
+++ unsigned char nc = static_cast<unsigned char>(m_str[idx + n]);
+++ valid &= ((nc & 0xC0) == 0x80);
+++ value = (value << 6) | (nc & 0x3F);
+++ }
+++
+++ if (
+++ // Wrong bit pattern of following bytes
+++ (!valid) ||
+++ // Overlong encodings
+++ (value < 0x80) ||
+++ (0x80 <= value && value < 0x800 && encBytes > 2) ||
+++ (0x800 < value && value < 0x10000 && encBytes > 3) ||
+++ // Encoded value out of range
+++ (value >= 0x110000)
+++ ) {
+++ hexEscapeChar(os, c);
+++ break;
+++ }
+++
+++ // If we got here, this is in fact a valid(ish) utf-8 sequence
+++ for (std::size_t n = 0; n < encBytes; ++n) {
+++ os << m_str[idx + n];
+++ }
+++ idx += encBytes - 1;
+++ break;
+++ }
+++ }
+++ }
+++
+++ std::ostream& operator << ( std::ostream& os, XmlEncode const& xmlEncode ) {
+++ xmlEncode.encodeTo( os );
+++ return os;
+++ }
+++
+++ XmlWriter::ScopedElement::ScopedElement( XmlWriter* writer, XmlFormatting fmt )
+++ : m_writer( writer ),
+++ m_fmt(fmt)
+++ {}
+++
+++ XmlWriter::ScopedElement::ScopedElement( ScopedElement&& other ) noexcept
+++ : m_writer( other.m_writer ),
+++ m_fmt(other.m_fmt)
+++ {
+++ other.m_writer = nullptr;
+++ other.m_fmt = XmlFormatting::None;
+++ }
+++ XmlWriter::ScopedElement& XmlWriter::ScopedElement::operator=( ScopedElement&& other ) noexcept {
+++ if ( m_writer ) {
+++ m_writer->endElement();
+++ }
+++ m_writer = other.m_writer;
+++ other.m_writer = nullptr;
+++ m_fmt = other.m_fmt;
+++ other.m_fmt = XmlFormatting::None;
+++ return *this;
+++ }
+++
+++
+++ XmlWriter::ScopedElement::~ScopedElement() {
+++ if (m_writer) {
+++ m_writer->endElement(m_fmt);
+++ }
+++ }
+++
+++ XmlWriter::ScopedElement&
+++ XmlWriter::ScopedElement::writeText( StringRef text, XmlFormatting fmt ) {
+++ m_writer->writeText( text, fmt );
+++ return *this;
+++ }
+++
+++ XmlWriter::ScopedElement&
+++ XmlWriter::ScopedElement::writeAttribute( StringRef name,
+++ StringRef attribute ) {
+++ m_writer->writeAttribute( name, attribute );
+++ return *this;
+++ }
+++
+++
+++ XmlWriter::XmlWriter( std::ostream& os ) : m_os( os )
+++ {
+++ writeDeclaration();
+++ }
+++
+++ XmlWriter::~XmlWriter() {
+++ while (!m_tags.empty()) {
+++ endElement();
+++ }
+++ newlineIfNecessary();
+++ }
+++
+++ XmlWriter& XmlWriter::startElement( std::string const& name, XmlFormatting fmt ) {
+++ ensureTagClosed();
+++ newlineIfNecessary();
+++ if (shouldIndent(fmt)) {
+++ m_os << m_indent;
+++ m_indent += " ";
+++ }
+++ m_os << '<' << name;
+++ m_tags.push_back( name );
+++ m_tagIsOpen = true;
+++ applyFormatting(fmt);
+++ return *this;
+++ }
+++
+++ XmlWriter::ScopedElement XmlWriter::scopedElement( std::string const& name, XmlFormatting fmt ) {
+++ ScopedElement scoped( this, fmt );
+++ startElement( name, fmt );
+++ return scoped;
+++ }
+++
+++ XmlWriter& XmlWriter::endElement(XmlFormatting fmt) {
+++ m_indent = m_indent.substr(0, m_indent.size() - 2);
+++
+++ if( m_tagIsOpen ) {
+++ m_os << "/>";
+++ m_tagIsOpen = false;
+++ } else {
+++ newlineIfNecessary();
+++ if (shouldIndent(fmt)) {
+++ m_os << m_indent;
+++ }
+++ m_os << "</" << m_tags.back() << '>';
+++ }
+++ m_os << std::flush;
+++ applyFormatting(fmt);
+++ m_tags.pop_back();
+++ return *this;
+++ }
+++
+++ XmlWriter& XmlWriter::writeAttribute( StringRef name,
+++ StringRef attribute ) {
+++ if( !name.empty() && !attribute.empty() )
+++ m_os << ' ' << name << "=\"" << XmlEncode( attribute, XmlEncode::ForAttributes ) << '"';
+++ return *this;
+++ }
+++
+++ XmlWriter& XmlWriter::writeAttribute( StringRef name, bool attribute ) {
+++ writeAttribute(name, (attribute ? "true"_sr : "false"_sr));
+++ return *this;
+++ }
+++
+++ XmlWriter& XmlWriter::writeAttribute( StringRef name,
+++ char const* attribute ) {
+++ writeAttribute( name, StringRef( attribute ) );
+++ return *this;
+++ }
+++
+++ XmlWriter& XmlWriter::writeText( StringRef text, XmlFormatting fmt ) {
+++ CATCH_ENFORCE(!m_tags.empty(), "Cannot write text as top level element");
+++ if( !text.empty() ){
+++ bool tagWasOpen = m_tagIsOpen;
+++ ensureTagClosed();
+++ if (tagWasOpen && shouldIndent(fmt)) {
+++ m_os << m_indent;
+++ }
+++ m_os << XmlEncode( text, XmlEncode::ForTextNodes );
+++ applyFormatting(fmt);
+++ }
+++ return *this;
+++ }
+++
+++ XmlWriter& XmlWriter::writeComment( StringRef text, XmlFormatting fmt ) {
+++ ensureTagClosed();
+++ if (shouldIndent(fmt)) {
+++ m_os << m_indent;
+++ }
+++ m_os << "<!-- " << text << " -->";
+++ applyFormatting(fmt);
+++ return *this;
+++ }
+++
+++ void XmlWriter::writeStylesheetRef( StringRef url ) {
+++ m_os << R"(<?xml-stylesheet type="text/xsl" href=")" << url << R"("?>)" << '\n';
+++ }
+++
+++ void XmlWriter::ensureTagClosed() {
+++ if( m_tagIsOpen ) {
+++ m_os << '>' << std::flush;
+++ newlineIfNecessary();
+++ m_tagIsOpen = false;
+++ }
+++ }
+++
+++ void XmlWriter::applyFormatting(XmlFormatting fmt) {
+++ m_needsNewline = shouldNewline(fmt);
+++ }
+++
+++ void XmlWriter::writeDeclaration() {
+++ m_os << R"(<?xml version="1.0" encoding="UTF-8"?>)" << '\n';
+++ }
+++
+++ void XmlWriter::newlineIfNecessary() {
+++ if( m_needsNewline ) {
+++ m_os << '\n' << std::flush;
+++ m_needsNewline = false;
+++ }
+++ }
+++}
+++
+++
+++
+++
+++
+++namespace Catch {
+++namespace Matchers {
+++
+++ std::string MatcherUntypedBase::toString() const {
+++ if (m_cachedToString.empty()) {
+++ m_cachedToString = describe();
+++ }
+++ return m_cachedToString;
+++ }
+++
+++ MatcherUntypedBase::~MatcherUntypedBase() = default;
+++
+++} // namespace Matchers
+++} // namespace Catch
+++
+++
+++
+++
+++namespace Catch {
+++namespace Matchers {
+++
+++ std::string IsEmptyMatcher::describe() const {
+++ return "is empty";
+++ }
+++
+++ std::string HasSizeMatcher::describe() const {
+++ ReusableStringStream sstr;
+++ sstr << "has size == " << m_target_size;
+++ return sstr.str();
+++ }
+++
+++ IsEmptyMatcher IsEmpty() {
+++ return {};
+++ }
+++
+++ HasSizeMatcher SizeIs(std::size_t sz) {
+++ return HasSizeMatcher{ sz };
+++ }
+++
+++} // end namespace Matchers
+++} // end namespace Catch
+++
+++
+++
+++namespace Catch {
+++namespace Matchers {
+++
+++bool ExceptionMessageMatcher::match(std::exception const& ex) const {
+++ return ex.what() == m_message;
+++}
+++
+++std::string ExceptionMessageMatcher::describe() const {
+++ return "exception message matches \"" + m_message + '"';
+++}
+++
+++ExceptionMessageMatcher Message(std::string const& message) {
+++ return ExceptionMessageMatcher(message);
+++}
+++
+++} // namespace Matchers
+++} // namespace Catch
+++
+++
+++
+++#include <algorithm>
+++#include <cmath>
+++#include <cstdlib>
+++#include <cstdint>
+++#include <sstream>
+++#include <iomanip>
+++#include <limits>
+++
+++
+++namespace Catch {
+++namespace {
+++
+++ template <typename FP>
+++ bool almostEqualUlps(FP lhs, FP rhs, uint64_t maxUlpDiff) {
+++ // Comparison with NaN should always be false.
+++ // This way we can rule it out before getting into the ugly details
+++ if (Catch::isnan(lhs) || Catch::isnan(rhs)) {
+++ return false;
+++ }
+++
+++ // This should also handle positive and negative zeros, infinities
+++ const auto ulpDist = ulpDistance(lhs, rhs);
+++
+++ return ulpDist <= maxUlpDiff;
+++ }
+++
+++
+++template <typename FP>
+++FP step(FP start, FP direction, uint64_t steps) {
+++ for (uint64_t i = 0; i < steps; ++i) {
+++ start = Catch::nextafter(start, direction);
+++ }
+++ return start;
+++}
+++
+++// Performs equivalent check of std::fabs(lhs - rhs) <= margin
+++// But without the subtraction to allow for INFINITY in comparison
+++bool marginComparison(double lhs, double rhs, double margin) {
+++ return (lhs + margin >= rhs) && (rhs + margin >= lhs);
+++}
+++
+++template <typename FloatingPoint>
+++void write(std::ostream& out, FloatingPoint num) {
+++ out << std::scientific
+++ << std::setprecision(std::numeric_limits<FloatingPoint>::max_digits10 - 1)
+++ << num;
+++}
+++
+++} // end anonymous namespace
+++
+++namespace Matchers {
+++namespace Detail {
+++
+++ enum class FloatingPointKind : uint8_t {
+++ Float,
+++ Double
+++ };
+++
+++} // end namespace Detail
+++
+++
+++ WithinAbsMatcher::WithinAbsMatcher(double target, double margin)
+++ :m_target{ target }, m_margin{ margin } {
+++ CATCH_ENFORCE(margin >= 0, "Invalid margin: " << margin << '.'
+++ << " Margin has to be non-negative.");
+++ }
+++
+++ // Performs equivalent check of std::fabs(lhs - rhs) <= margin
+++ // But without the subtraction to allow for INFINITY in comparison
+++ bool WithinAbsMatcher::match(double const& matchee) const {
+++ return (matchee + m_margin >= m_target) && (m_target + m_margin >= matchee);
+++ }
+++
+++ std::string WithinAbsMatcher::describe() const {
+++ return "is within " + ::Catch::Detail::stringify(m_margin) + " of " + ::Catch::Detail::stringify(m_target);
+++ }
+++
+++
+++ WithinUlpsMatcher::WithinUlpsMatcher(double target, uint64_t ulps, Detail::FloatingPointKind baseType)
+++ :m_target{ target }, m_ulps{ ulps }, m_type{ baseType } {
+++ CATCH_ENFORCE(m_type == Detail::FloatingPointKind::Double
+++ || m_ulps < (std::numeric_limits<uint32_t>::max)(),
+++ "Provided ULP is impossibly large for a float comparison.");
+++ CATCH_ENFORCE( std::numeric_limits<double>::is_iec559,
+++ "WithinUlp matcher only supports platforms with "
+++ "IEEE-754 compatible floating point representation" );
+++ }
+++
+++#if defined(__clang__)
+++#pragma clang diagnostic push
+++// Clang <3.5 reports on the default branch in the switch below
+++#pragma clang diagnostic ignored "-Wunreachable-code"
+++#endif
+++
+++ bool WithinUlpsMatcher::match(double const& matchee) const {
+++ switch (m_type) {
+++ case Detail::FloatingPointKind::Float:
+++ return almostEqualUlps<float>(static_cast<float>(matchee), static_cast<float>(m_target), m_ulps);
+++ case Detail::FloatingPointKind::Double:
+++ return almostEqualUlps<double>(matchee, m_target, m_ulps);
+++ default:
+++ CATCH_INTERNAL_ERROR( "Unknown Detail::FloatingPointKind value" );
+++ }
+++ }
+++
+++#if defined(__clang__)
+++#pragma clang diagnostic pop
+++#endif
+++
+++ std::string WithinUlpsMatcher::describe() const {
+++ std::stringstream ret;
+++
+++ ret << "is within " << m_ulps << " ULPs of ";
+++
+++ if (m_type == Detail::FloatingPointKind::Float) {
+++ write(ret, static_cast<float>(m_target));
+++ ret << 'f';
+++ } else {
+++ write(ret, m_target);
+++ }
+++
+++ ret << " ([";
+++ if (m_type == Detail::FloatingPointKind::Double) {
+++ write( ret,
+++ step( m_target,
+++ -std::numeric_limits<double>::infinity(),
+++ m_ulps ) );
+++ ret << ", ";
+++ write( ret,
+++ step( m_target,
+++ std::numeric_limits<double>::infinity(),
+++ m_ulps ) );
+++ } else {
+++ // We have to cast INFINITY to float because of MinGW, see #1782
+++ write( ret,
+++ step( static_cast<float>( m_target ),
+++ -std::numeric_limits<float>::infinity(),
+++ m_ulps ) );
+++ ret << ", ";
+++ write( ret,
+++ step( static_cast<float>( m_target ),
+++ std::numeric_limits<float>::infinity(),
+++ m_ulps ) );
+++ }
+++ ret << "])";
+++
+++ return ret.str();
+++ }
+++
+++ WithinRelMatcher::WithinRelMatcher(double target, double epsilon):
+++ m_target(target),
+++ m_epsilon(epsilon){
+++ CATCH_ENFORCE(m_epsilon >= 0., "Relative comparison with epsilon < 0 does not make sense.");
+++ CATCH_ENFORCE(m_epsilon < 1., "Relative comparison with epsilon >= 1 does not make sense.");
+++ }
+++
+++ bool WithinRelMatcher::match(double const& matchee) const {
+++ const auto relMargin = m_epsilon * (std::max)(std::fabs(matchee), std::fabs(m_target));
+++ return marginComparison(matchee, m_target,
+++ std::isinf(relMargin)? 0 : relMargin);
+++ }
+++
+++ std::string WithinRelMatcher::describe() const {
+++ Catch::ReusableStringStream sstr;
+++ sstr << "and " << ::Catch::Detail::stringify(m_target) << " are within " << m_epsilon * 100. << "% of each other";
+++ return sstr.str();
+++ }
+++
+++
+++WithinUlpsMatcher WithinULP(double target, uint64_t maxUlpDiff) {
+++ return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Double);
+++}
+++
+++WithinUlpsMatcher WithinULP(float target, uint64_t maxUlpDiff) {
+++ return WithinUlpsMatcher(target, maxUlpDiff, Detail::FloatingPointKind::Float);
+++}
+++
+++WithinAbsMatcher WithinAbs(double target, double margin) {
+++ return WithinAbsMatcher(target, margin);
+++}
+++
+++WithinRelMatcher WithinRel(double target, double eps) {
+++ return WithinRelMatcher(target, eps);
+++}
+++
+++WithinRelMatcher WithinRel(double target) {
+++ return WithinRelMatcher(target, std::numeric_limits<double>::epsilon() * 100);
+++}
+++
+++WithinRelMatcher WithinRel(float target, float eps) {
+++ return WithinRelMatcher(target, eps);
+++}
+++
+++WithinRelMatcher WithinRel(float target) {
+++ return WithinRelMatcher(target, std::numeric_limits<float>::epsilon() * 100);
+++}
+++
+++
+++
+++bool IsNaNMatcher::match( double const& matchee ) const {
+++ return std::isnan( matchee );
+++}
+++
+++std::string IsNaNMatcher::describe() const {
+++ using namespace std::string_literals;
+++ return "is NaN"s;
+++}
+++
+++IsNaNMatcher IsNaN() { return IsNaNMatcher(); }
+++
+++ } // namespace Matchers
+++} // namespace Catch
+++
+++
+++
+++
+++std::string Catch::Matchers::Detail::finalizeDescription(const std::string& desc) {
+++ if (desc.empty()) {
+++ return "matches undescribed predicate";
+++ } else {
+++ return "matches predicate: \"" + desc + '"';
+++ }
+++}
+++
+++
+++
+++namespace Catch {
+++ namespace Matchers {
+++ std::string AllTrueMatcher::describe() const { return "contains only true"; }
+++
+++ AllTrueMatcher AllTrue() { return AllTrueMatcher{}; }
+++
+++ std::string NoneTrueMatcher::describe() const { return "contains no true"; }
+++
+++ NoneTrueMatcher NoneTrue() { return NoneTrueMatcher{}; }
+++
+++ std::string AnyTrueMatcher::describe() const { return "contains at least one true"; }
+++
+++ AnyTrueMatcher AnyTrue() { return AnyTrueMatcher{}; }
+++ } // namespace Matchers
+++} // namespace Catch
+++
+++
+++
+++#include <regex>
+++
+++namespace Catch {
+++namespace Matchers {
+++
+++ CasedString::CasedString( std::string const& str, CaseSensitive caseSensitivity )
+++ : m_caseSensitivity( caseSensitivity ),
+++ m_str( adjustString( str ) )
+++ {}
+++ std::string CasedString::adjustString( std::string const& str ) const {
+++ return m_caseSensitivity == CaseSensitive::No
+++ ? toLower( str )
+++ : str;
+++ }
+++ StringRef CasedString::caseSensitivitySuffix() const {
+++ return m_caseSensitivity == CaseSensitive::Yes
+++ ? StringRef()
+++ : " (case insensitive)"_sr;
+++ }
+++
+++
+++ StringMatcherBase::StringMatcherBase( StringRef operation, CasedString const& comparator )
+++ : m_comparator( comparator ),
+++ m_operation( operation ) {
+++ }
+++
+++ std::string StringMatcherBase::describe() const {
+++ std::string description;
+++ description.reserve(5 + m_operation.size() + m_comparator.m_str.size() +
+++ m_comparator.caseSensitivitySuffix().size());
+++ description += m_operation;
+++ description += ": \"";
+++ description += m_comparator.m_str;
+++ description += '"';
+++ description += m_comparator.caseSensitivitySuffix();
+++ return description;
+++ }
+++
+++ StringEqualsMatcher::StringEqualsMatcher( CasedString const& comparator ) : StringMatcherBase( "equals"_sr, comparator ) {}
+++
+++ bool StringEqualsMatcher::match( std::string const& source ) const {
+++ return m_comparator.adjustString( source ) == m_comparator.m_str;
+++ }
+++
+++
+++ StringContainsMatcher::StringContainsMatcher( CasedString const& comparator ) : StringMatcherBase( "contains"_sr, comparator ) {}
+++
+++ bool StringContainsMatcher::match( std::string const& source ) const {
+++ return contains( m_comparator.adjustString( source ), m_comparator.m_str );
+++ }
+++
+++
+++ StartsWithMatcher::StartsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "starts with"_sr, comparator ) {}
+++
+++ bool StartsWithMatcher::match( std::string const& source ) const {
+++ return startsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+++ }
+++
+++
+++ EndsWithMatcher::EndsWithMatcher( CasedString const& comparator ) : StringMatcherBase( "ends with"_sr, comparator ) {}
+++
+++ bool EndsWithMatcher::match( std::string const& source ) const {
+++ return endsWith( m_comparator.adjustString( source ), m_comparator.m_str );
+++ }
+++
+++
+++
+++ RegexMatcher::RegexMatcher(std::string regex, CaseSensitive caseSensitivity): m_regex(CATCH_MOVE(regex)), m_caseSensitivity(caseSensitivity) {}
+++
+++ bool RegexMatcher::match(std::string const& matchee) const {
+++ auto flags = std::regex::ECMAScript; // ECMAScript is the default syntax option anyway
+++ if (m_caseSensitivity == CaseSensitive::No) {
+++ flags |= std::regex::icase;
+++ }
+++ auto reg = std::regex(m_regex, flags);
+++ return std::regex_match(matchee, reg);
+++ }
+++
+++ std::string RegexMatcher::describe() const {
+++ return "matches " + ::Catch::Detail::stringify(m_regex) + ((m_caseSensitivity == CaseSensitive::Yes)? " case sensitively" : " case insensitively");
+++ }
+++
+++
+++ StringEqualsMatcher Equals( std::string const& str, CaseSensitive caseSensitivity ) {
+++ return StringEqualsMatcher( CasedString( str, caseSensitivity) );
+++ }
+++ StringContainsMatcher ContainsSubstring( std::string const& str, CaseSensitive caseSensitivity ) {
+++ return StringContainsMatcher( CasedString( str, caseSensitivity) );
+++ }
+++ EndsWithMatcher EndsWith( std::string const& str, CaseSensitive caseSensitivity ) {
+++ return EndsWithMatcher( CasedString( str, caseSensitivity) );
+++ }
+++ StartsWithMatcher StartsWith( std::string const& str, CaseSensitive caseSensitivity ) {
+++ return StartsWithMatcher( CasedString( str, caseSensitivity) );
+++ }
+++
+++ RegexMatcher Matches(std::string const& regex, CaseSensitive caseSensitivity) {
+++ return RegexMatcher(regex, caseSensitivity);
+++ }
+++
+++} // namespace Matchers
+++} // namespace Catch
+++
+++
+++
+++namespace Catch {
+++namespace Matchers {
+++ MatcherGenericBase::~MatcherGenericBase() = default;
+++
+++ namespace Detail {
+++
+++ std::string describe_multi_matcher(StringRef combine, std::string const* descriptions_begin, std::string const* descriptions_end) {
+++ std::string description;
+++ std::size_t combined_size = 4;
+++ for ( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) {
+++ combined_size += desc->size();
+++ }
+++ combined_size += static_cast<size_t>(descriptions_end - descriptions_begin - 1) * combine.size();
+++
+++ description.reserve(combined_size);
+++
+++ description += "( ";
+++ bool first = true;
+++ for( auto desc = descriptions_begin; desc != descriptions_end; ++desc ) {
+++ if( first )
+++ first = false;
+++ else
+++ description += combine;
+++ description += *desc;
+++ }
+++ description += " )";
+++ return description;
+++ }
+++
+++ } // namespace Detail
+++} // namespace Matchers
+++} // namespace Catch
+++
+++
+++
+++
+++namespace Catch {
+++
+++ // This is the general overload that takes a any string matcher
+++ // There is another overload, in catch_assertionhandler.h/.cpp, that only takes a string and infers
+++ // the Equals matcher (so the header does not mention matchers)
+++ void handleExceptionMatchExpr( AssertionHandler& handler, StringMatcher const& matcher ) {
+++ std::string exceptionMessage = Catch::translateActiveException();
+++ MatchExpr<std::string, StringMatcher const&> expr( CATCH_MOVE(exceptionMessage), matcher );
+++ handler.handleExpr( expr );
+++ }
+++
+++} // namespace Catch
+++
+++
+++
+++#include <ostream>
+++
+++namespace Catch {
+++
+++ AutomakeReporter::~AutomakeReporter() = default;
+++
+++ void AutomakeReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
+++ // Possible values to emit are PASS, XFAIL, SKIP, FAIL, XPASS and ERROR.
+++ m_stream << ":test-result: ";
+++ if ( _testCaseStats.totals.testCases.skipped > 0 ) {
+++ m_stream << "SKIP";
+++ } else if (_testCaseStats.totals.assertions.allPassed()) {
+++ m_stream << "PASS";
+++ } else if (_testCaseStats.totals.assertions.allOk()) {
+++ m_stream << "XFAIL";
+++ } else {
+++ m_stream << "FAIL";
+++ }
+++ m_stream << ' ' << _testCaseStats.testInfo->name << '\n';
+++ StreamingReporterBase::testCaseEnded(_testCaseStats);
+++ }
+++
+++ void AutomakeReporter::skipTest(TestCaseInfo const& testInfo) {
+++ m_stream << ":test-result: SKIP " << testInfo.name << '\n';
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++
+++
+++namespace Catch {
+++ ReporterBase::ReporterBase( ReporterConfig&& config ):
+++ IEventListener( config.fullConfig() ),
+++ m_wrapped_stream( CATCH_MOVE(config).takeStream() ),
+++ m_stream( m_wrapped_stream->stream() ),
+++ m_colour( makeColourImpl( config.colourMode(), m_wrapped_stream.get() ) ),
+++ m_customOptions( config.customOptions() )
+++ {}
+++
+++ ReporterBase::~ReporterBase() = default;
+++
+++ void ReporterBase::listReporters(
+++ std::vector<ReporterDescription> const& descriptions ) {
+++ defaultListReporters(m_stream, descriptions, m_config->verbosity());
+++ }
+++
+++ void ReporterBase::listListeners(
+++ std::vector<ListenerDescription> const& descriptions ) {
+++ defaultListListeners( m_stream, descriptions );
+++ }
+++
+++ void ReporterBase::listTests(std::vector<TestCaseHandle> const& tests) {
+++ defaultListTests(m_stream,
+++ m_colour.get(),
+++ tests,
+++ m_config->hasTestFilters(),
+++ m_config->verbosity());
+++ }
+++
+++ void ReporterBase::listTags(std::vector<TagInfo> const& tags) {
+++ defaultListTags( m_stream, tags, m_config->hasTestFilters() );
+++ }
+++
+++} // namespace Catch
+++
+++
+++
+++
+++#include <ostream>
+++
+++namespace Catch {
+++namespace {
+++
+++ // Colour::LightGrey
+++ static constexpr Colour::Code compactDimColour = Colour::FileName;
+++
+++#ifdef CATCH_PLATFORM_MAC
+++ static constexpr Catch::StringRef compactFailedString = "FAILED"_sr;
+++ static constexpr Catch::StringRef compactPassedString = "PASSED"_sr;
+++#else
+++ static constexpr Catch::StringRef compactFailedString = "failed"_sr;
+++ static constexpr Catch::StringRef compactPassedString = "passed"_sr;
+++#endif
+++
+++// Implementation of CompactReporter formatting
+++class AssertionPrinter {
+++public:
+++ AssertionPrinter& operator= (AssertionPrinter const&) = delete;
+++ AssertionPrinter(AssertionPrinter const&) = delete;
+++ AssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, bool _printInfoMessages, ColourImpl* colourImpl_)
+++ : stream(_stream)
+++ , result(_stats.assertionResult)
+++ , messages(_stats.infoMessages)
+++ , itMessage(_stats.infoMessages.begin())
+++ , printInfoMessages(_printInfoMessages)
+++ , colourImpl(colourImpl_)
+++ {}
+++
+++ void print() {
+++ printSourceInfo();
+++
+++ itMessage = messages.begin();
+++
+++ switch (result.getResultType()) {
+++ case ResultWas::Ok:
+++ printResultType(Colour::ResultSuccess, compactPassedString);
+++ printOriginalExpression();
+++ printReconstructedExpression();
+++ if (!result.hasExpression())
+++ printRemainingMessages(Colour::None);
+++ else
+++ printRemainingMessages();
+++ break;
+++ case ResultWas::ExpressionFailed:
+++ if (result.isOk())
+++ printResultType(Colour::ResultSuccess, compactFailedString + " - but was ok"_sr);
+++ else
+++ printResultType(Colour::Error, compactFailedString);
+++ printOriginalExpression();
+++ printReconstructedExpression();
+++ printRemainingMessages();
+++ break;
+++ case ResultWas::ThrewException:
+++ printResultType(Colour::Error, compactFailedString);
+++ printIssue("unexpected exception with message:");
+++ printMessage();
+++ printExpressionWas();
+++ printRemainingMessages();
+++ break;
+++ case ResultWas::FatalErrorCondition:
+++ printResultType(Colour::Error, compactFailedString);
+++ printIssue("fatal error condition with message:");
+++ printMessage();
+++ printExpressionWas();
+++ printRemainingMessages();
+++ break;
+++ case ResultWas::DidntThrowException:
+++ printResultType(Colour::Error, compactFailedString);
+++ printIssue("expected exception, got none");
+++ printExpressionWas();
+++ printRemainingMessages();
+++ break;
+++ case ResultWas::Info:
+++ printResultType(Colour::None, "info"_sr);
+++ printMessage();
+++ printRemainingMessages();
+++ break;
+++ case ResultWas::Warning:
+++ printResultType(Colour::None, "warning"_sr);
+++ printMessage();
+++ printRemainingMessages();
+++ break;
+++ case ResultWas::ExplicitFailure:
+++ printResultType(Colour::Error, compactFailedString);
+++ printIssue("explicitly");
+++ printRemainingMessages(Colour::None);
+++ break;
+++ case ResultWas::ExplicitSkip:
+++ printResultType(Colour::Skip, "skipped"_sr);
+++ printMessage();
+++ printRemainingMessages();
+++ break;
+++ // These cases are here to prevent compiler warnings
+++ case ResultWas::Unknown:
+++ case ResultWas::FailureBit:
+++ case ResultWas::Exception:
+++ printResultType(Colour::Error, "** internal error **");
+++ break;
+++ }
+++ }
+++
+++private:
+++ void printSourceInfo() const {
+++ stream << colourImpl->guardColour( Colour::FileName )
+++ << result.getSourceInfo() << ':';
+++ }
+++
+++ void printResultType(Colour::Code colour, StringRef passOrFail) const {
+++ if (!passOrFail.empty()) {
+++ stream << colourImpl->guardColour(colour) << ' ' << passOrFail;
+++ stream << ':';
+++ }
+++ }
+++
+++ void printIssue(char const* issue) const {
+++ stream << ' ' << issue;
+++ }
+++
+++ void printExpressionWas() {
+++ if (result.hasExpression()) {
+++ stream << ';';
+++ {
+++ stream << colourImpl->guardColour(compactDimColour) << " expression was:";
+++ }
+++ printOriginalExpression();
+++ }
+++ }
+++
+++ void printOriginalExpression() const {
+++ if (result.hasExpression()) {
+++ stream << ' ' << result.getExpression();
+++ }
+++ }
+++
+++ void printReconstructedExpression() const {
+++ if (result.hasExpandedExpression()) {
+++ stream << colourImpl->guardColour(compactDimColour) << " for: ";
+++ stream << result.getExpandedExpression();
+++ }
+++ }
+++
+++ void printMessage() {
+++ if (itMessage != messages.end()) {
+++ stream << " '" << itMessage->message << '\'';
+++ ++itMessage;
+++ }
+++ }
+++
+++ void printRemainingMessages(Colour::Code colour = compactDimColour) {
+++ if (itMessage == messages.end())
+++ return;
+++
+++ const auto itEnd = messages.cend();
+++ const auto N = static_cast<std::size_t>(itEnd - itMessage);
+++
+++ stream << colourImpl->guardColour( colour ) << " with "
+++ << pluralise( N, "message"_sr ) << ':';
+++
+++ while (itMessage != itEnd) {
+++ // If this assertion is a warning ignore any INFO messages
+++ if (printInfoMessages || itMessage->type != ResultWas::Info) {
+++ printMessage();
+++ if (itMessage != itEnd) {
+++ stream << colourImpl->guardColour(compactDimColour) << " and";
+++ }
+++ continue;
+++ }
+++ ++itMessage;
+++ }
+++ }
+++
+++private:
+++ std::ostream& stream;
+++ AssertionResult const& result;
+++ std::vector<MessageInfo> const& messages;
+++ std::vector<MessageInfo>::const_iterator itMessage;
+++ bool printInfoMessages;
+++ ColourImpl* colourImpl;
+++};
+++
+++} // anon namespace
+++
+++ std::string CompactReporter::getDescription() {
+++ return "Reports test results on a single line, suitable for IDEs";
+++ }
+++
+++ void CompactReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
+++ m_stream << "No test cases matched '" << unmatchedSpec << "'\n";
+++ }
+++
+++ void CompactReporter::testRunStarting( TestRunInfo const& ) {
+++ if ( m_config->testSpec().hasFilters() ) {
+++ m_stream << m_colour->guardColour( Colour::BrightYellow )
+++ << "Filters: "
+++ << m_config->testSpec()
+++ << '\n';
+++ }
+++ m_stream << "RNG seed: " << getSeed() << '\n';
+++ }
+++
+++ void CompactReporter::assertionEnded( AssertionStats const& _assertionStats ) {
+++ AssertionResult const& result = _assertionStats.assertionResult;
+++
+++ bool printInfoMessages = true;
+++
+++ // Drop out if result was successful and we're not printing those
+++ if( !m_config->includeSuccessfulResults() && result.isOk() ) {
+++ if( result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip )
+++ return;
+++ printInfoMessages = false;
+++ }
+++
+++ AssertionPrinter printer( m_stream, _assertionStats, printInfoMessages, m_colour.get() );
+++ printer.print();
+++
+++ m_stream << '\n' << std::flush;
+++ }
+++
+++ void CompactReporter::sectionEnded(SectionStats const& _sectionStats) {
+++ double dur = _sectionStats.durationInSeconds;
+++ if ( shouldShowDuration( *m_config, dur ) ) {
+++ m_stream << getFormattedDuration( dur ) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush;
+++ }
+++ }
+++
+++ void CompactReporter::testRunEnded( TestRunStats const& _testRunStats ) {
+++ printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
+++ m_stream << "\n\n" << std::flush;
+++ StreamingReporterBase::testRunEnded( _testRunStats );
+++ }
+++
+++ CompactReporter::~CompactReporter() = default;
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++#include <cstdio>
+++
+++#if defined(_MSC_VER)
+++#pragma warning(push)
+++#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+++ // Note that 4062 (not all labels are handled and default is missing) is enabled
+++#endif
+++
+++#if defined(__clang__)
+++# pragma clang diagnostic push
+++// For simplicity, benchmarking-only helpers are always enabled
+++# pragma clang diagnostic ignored "-Wunused-function"
+++#endif
+++
+++
+++
+++namespace Catch {
+++
+++namespace {
+++
+++// Formatter impl for ConsoleReporter
+++class ConsoleAssertionPrinter {
+++public:
+++ ConsoleAssertionPrinter& operator= (ConsoleAssertionPrinter const&) = delete;
+++ ConsoleAssertionPrinter(ConsoleAssertionPrinter const&) = delete;
+++ ConsoleAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, ColourImpl* colourImpl_, bool _printInfoMessages)
+++ : stream(_stream),
+++ stats(_stats),
+++ result(_stats.assertionResult),
+++ colour(Colour::None),
+++ messages(_stats.infoMessages),
+++ colourImpl(colourImpl_),
+++ printInfoMessages(_printInfoMessages) {
+++ switch (result.getResultType()) {
+++ case ResultWas::Ok:
+++ colour = Colour::Success;
+++ passOrFail = "PASSED"_sr;
+++ //if( result.hasMessage() )
+++ if (messages.size() == 1)
+++ messageLabel = "with message"_sr;
+++ if (messages.size() > 1)
+++ messageLabel = "with messages"_sr;
+++ break;
+++ case ResultWas::ExpressionFailed:
+++ if (result.isOk()) {
+++ colour = Colour::Success;
+++ passOrFail = "FAILED - but was ok"_sr;
+++ } else {
+++ colour = Colour::Error;
+++ passOrFail = "FAILED"_sr;
+++ }
+++ if (messages.size() == 1)
+++ messageLabel = "with message"_sr;
+++ if (messages.size() > 1)
+++ messageLabel = "with messages"_sr;
+++ break;
+++ case ResultWas::ThrewException:
+++ colour = Colour::Error;
+++ passOrFail = "FAILED"_sr;
+++ // todo switch
+++ switch (messages.size()) { case 0:
+++ messageLabel = "due to unexpected exception with "_sr;
+++ break;
+++ case 1:
+++ messageLabel = "due to unexpected exception with message"_sr;
+++ break;
+++ default:
+++ messageLabel = "due to unexpected exception with messages"_sr;
+++ break;
+++ }
+++ break;
+++ case ResultWas::FatalErrorCondition:
+++ colour = Colour::Error;
+++ passOrFail = "FAILED"_sr;
+++ messageLabel = "due to a fatal error condition"_sr;
+++ break;
+++ case ResultWas::DidntThrowException:
+++ colour = Colour::Error;
+++ passOrFail = "FAILED"_sr;
+++ messageLabel = "because no exception was thrown where one was expected"_sr;
+++ break;
+++ case ResultWas::Info:
+++ messageLabel = "info"_sr;
+++ break;
+++ case ResultWas::Warning:
+++ messageLabel = "warning"_sr;
+++ break;
+++ case ResultWas::ExplicitFailure:
+++ passOrFail = "FAILED"_sr;
+++ colour = Colour::Error;
+++ if (messages.size() == 1)
+++ messageLabel = "explicitly with message"_sr;
+++ if (messages.size() > 1)
+++ messageLabel = "explicitly with messages"_sr;
+++ break;
+++ case ResultWas::ExplicitSkip:
+++ colour = Colour::Skip;
+++ passOrFail = "SKIPPED"_sr;
+++ if (messages.size() == 1)
+++ messageLabel = "explicitly with message"_sr;
+++ if (messages.size() > 1)
+++ messageLabel = "explicitly with messages"_sr;
+++ break;
+++ // These cases are here to prevent compiler warnings
+++ case ResultWas::Unknown:
+++ case ResultWas::FailureBit:
+++ case ResultWas::Exception:
+++ passOrFail = "** internal error **"_sr;
+++ colour = Colour::Error;
+++ break;
+++ }
+++ }
+++
+++ void print() const {
+++ printSourceInfo();
+++ if (stats.totals.assertions.total() > 0) {
+++ printResultType();
+++ printOriginalExpression();
+++ printReconstructedExpression();
+++ } else {
+++ stream << '\n';
+++ }
+++ printMessage();
+++ }
+++
+++private:
+++ void printResultType() const {
+++ if (!passOrFail.empty()) {
+++ stream << colourImpl->guardColour(colour) << passOrFail << ":\n";
+++ }
+++ }
+++ void printOriginalExpression() const {
+++ if (result.hasExpression()) {
+++ stream << colourImpl->guardColour( Colour::OriginalExpression )
+++ << " " << result.getExpressionInMacro() << '\n';
+++ }
+++ }
+++ void printReconstructedExpression() const {
+++ if (result.hasExpandedExpression()) {
+++ stream << "with expansion:\n";
+++ stream << colourImpl->guardColour( Colour::ReconstructedExpression )
+++ << TextFlow::Column( result.getExpandedExpression() )
+++ .indent( 2 )
+++ << '\n';
+++ }
+++ }
+++ void printMessage() const {
+++ if (!messageLabel.empty())
+++ stream << messageLabel << ':' << '\n';
+++ for (auto const& msg : messages) {
+++ // If this assertion is a warning ignore any INFO messages
+++ if (printInfoMessages || msg.type != ResultWas::Info)
+++ stream << TextFlow::Column(msg.message).indent(2) << '\n';
+++ }
+++ }
+++ void printSourceInfo() const {
+++ stream << colourImpl->guardColour( Colour::FileName )
+++ << result.getSourceInfo() << ": ";
+++ }
+++
+++ std::ostream& stream;
+++ AssertionStats const& stats;
+++ AssertionResult const& result;
+++ Colour::Code colour;
+++ StringRef passOrFail;
+++ StringRef messageLabel;
+++ std::vector<MessageInfo> const& messages;
+++ ColourImpl* colourImpl;
+++ bool printInfoMessages;
+++};
+++
+++std::size_t makeRatio( std::uint64_t number, std::uint64_t total ) {
+++ const auto ratio = total > 0 ? CATCH_CONFIG_CONSOLE_WIDTH * number / total : 0;
+++ return (ratio == 0 && number > 0) ? 1 : static_cast<std::size_t>(ratio);
+++}
+++
+++std::size_t&
+++findMax( std::size_t& i, std::size_t& j, std::size_t& k, std::size_t& l ) {
+++ if (i > j && i > k && i > l)
+++ return i;
+++ else if (j > k && j > l)
+++ return j;
+++ else if (k > l)
+++ return k;
+++ else
+++ return l;
+++}
+++
+++struct ColumnBreak {};
+++struct RowBreak {};
+++struct OutputFlush {};
+++
+++class Duration {
+++ enum class Unit {
+++ Auto,
+++ Nanoseconds,
+++ Microseconds,
+++ Milliseconds,
+++ Seconds,
+++ Minutes
+++ };
+++ static const uint64_t s_nanosecondsInAMicrosecond = 1000;
+++ static const uint64_t s_nanosecondsInAMillisecond = 1000 * s_nanosecondsInAMicrosecond;
+++ static const uint64_t s_nanosecondsInASecond = 1000 * s_nanosecondsInAMillisecond;
+++ static const uint64_t s_nanosecondsInAMinute = 60 * s_nanosecondsInASecond;
+++
+++ double m_inNanoseconds;
+++ Unit m_units;
+++
+++public:
+++ explicit Duration(double inNanoseconds, Unit units = Unit::Auto)
+++ : m_inNanoseconds(inNanoseconds),
+++ m_units(units) {
+++ if (m_units == Unit::Auto) {
+++ if (m_inNanoseconds < s_nanosecondsInAMicrosecond)
+++ m_units = Unit::Nanoseconds;
+++ else if (m_inNanoseconds < s_nanosecondsInAMillisecond)
+++ m_units = Unit::Microseconds;
+++ else if (m_inNanoseconds < s_nanosecondsInASecond)
+++ m_units = Unit::Milliseconds;
+++ else if (m_inNanoseconds < s_nanosecondsInAMinute)
+++ m_units = Unit::Seconds;
+++ else
+++ m_units = Unit::Minutes;
+++ }
+++
+++ }
+++
+++ auto value() const -> double {
+++ switch (m_units) {
+++ case Unit::Microseconds:
+++ return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMicrosecond);
+++ case Unit::Milliseconds:
+++ return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMillisecond);
+++ case Unit::Seconds:
+++ return m_inNanoseconds / static_cast<double>(s_nanosecondsInASecond);
+++ case Unit::Minutes:
+++ return m_inNanoseconds / static_cast<double>(s_nanosecondsInAMinute);
+++ default:
+++ return m_inNanoseconds;
+++ }
+++ }
+++ StringRef unitsAsString() const {
+++ switch (m_units) {
+++ case Unit::Nanoseconds:
+++ return "ns"_sr;
+++ case Unit::Microseconds:
+++ return "us"_sr;
+++ case Unit::Milliseconds:
+++ return "ms"_sr;
+++ case Unit::Seconds:
+++ return "s"_sr;
+++ case Unit::Minutes:
+++ return "m"_sr;
+++ default:
+++ return "** internal error **"_sr;
+++ }
+++
+++ }
+++ friend auto operator << (std::ostream& os, Duration const& duration) -> std::ostream& {
+++ return os << duration.value() << ' ' << duration.unitsAsString();
+++ }
+++};
+++} // end anon namespace
+++
+++enum class Justification { Left, Right };
+++
+++struct ColumnInfo {
+++ std::string name;
+++ std::size_t width;
+++ Justification justification;
+++};
+++
+++class TablePrinter {
+++ std::ostream& m_os;
+++ std::vector<ColumnInfo> m_columnInfos;
+++ ReusableStringStream m_oss;
+++ int m_currentColumn = -1;
+++ bool m_isOpen = false;
+++
+++public:
+++ TablePrinter( std::ostream& os, std::vector<ColumnInfo> columnInfos )
+++ : m_os( os ),
+++ m_columnInfos( CATCH_MOVE( columnInfos ) ) {}
+++
+++ auto columnInfos() const -> std::vector<ColumnInfo> const& {
+++ return m_columnInfos;
+++ }
+++
+++ void open() {
+++ if (!m_isOpen) {
+++ m_isOpen = true;
+++ *this << RowBreak();
+++
+++ TextFlow::Columns headerCols;
+++ for (auto const& info : m_columnInfos) {
+++ assert(info.width > 2);
+++ headerCols += TextFlow::Column(info.name).width(info.width - 2);
+++ headerCols += TextFlow::Spacer( 2 );
+++ }
+++ m_os << headerCols << '\n';
+++
+++ m_os << lineOfChars('-') << '\n';
+++ }
+++ }
+++ void close() {
+++ if (m_isOpen) {
+++ *this << RowBreak();
+++ m_os << '\n' << std::flush;
+++ m_isOpen = false;
+++ }
+++ }
+++
+++ template<typename T>
+++ friend TablePrinter& operator<< (TablePrinter& tp, T const& value) {
+++ tp.m_oss << value;
+++ return tp;
+++ }
+++
+++ friend TablePrinter& operator<< (TablePrinter& tp, ColumnBreak) {
+++ auto colStr = tp.m_oss.str();
+++ const auto strSize = colStr.size();
+++ tp.m_oss.str("");
+++ tp.open();
+++ if (tp.m_currentColumn == static_cast<int>(tp.m_columnInfos.size() - 1)) {
+++ tp.m_currentColumn = -1;
+++ tp.m_os << '\n';
+++ }
+++ tp.m_currentColumn++;
+++
+++ auto colInfo = tp.m_columnInfos[tp.m_currentColumn];
+++ auto padding = (strSize + 1 < colInfo.width)
+++ ? std::string(colInfo.width - (strSize + 1), ' ')
+++ : std::string();
+++ if (colInfo.justification == Justification::Left)
+++ tp.m_os << colStr << padding << ' ';
+++ else
+++ tp.m_os << padding << colStr << ' ';
+++ return tp;
+++ }
+++
+++ friend TablePrinter& operator<< (TablePrinter& tp, RowBreak) {
+++ if (tp.m_currentColumn > 0) {
+++ tp.m_os << '\n';
+++ tp.m_currentColumn = -1;
+++ }
+++ return tp;
+++ }
+++
+++ friend TablePrinter& operator<<(TablePrinter& tp, OutputFlush) {
+++ tp.m_os << std::flush;
+++ return tp;
+++ }
+++};
+++
+++ConsoleReporter::ConsoleReporter(ReporterConfig&& config):
+++ StreamingReporterBase( CATCH_MOVE( config ) ),
+++ m_tablePrinter(Detail::make_unique<TablePrinter>(m_stream,
+++ [&config]() -> std::vector<ColumnInfo> {
+++ if (config.fullConfig()->benchmarkNoAnalysis())
+++ {
+++ return{
+++ { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left },
+++ { " samples", 14, Justification::Right },
+++ { " iterations", 14, Justification::Right },
+++ { " mean", 14, Justification::Right }
+++ };
+++ }
+++ else
+++ {
+++ return{
+++ { "benchmark name", CATCH_CONFIG_CONSOLE_WIDTH - 43, Justification::Left },
+++ { "samples mean std dev", 14, Justification::Right },
+++ { "iterations low mean low std dev", 14, Justification::Right },
+++ { "est run time high mean high std dev", 14, Justification::Right }
+++ };
+++ }
+++ }())) {}
+++ConsoleReporter::~ConsoleReporter() = default;
+++
+++std::string ConsoleReporter::getDescription() {
+++ return "Reports test results as plain lines of text";
+++}
+++
+++void ConsoleReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
+++ m_stream << "No test cases matched '" << unmatchedSpec << "'\n";
+++}
+++
+++void ConsoleReporter::reportInvalidTestSpec( StringRef arg ) {
+++ m_stream << "Invalid Filter: " << arg << '\n';
+++}
+++
+++void ConsoleReporter::assertionStarting(AssertionInfo const&) {}
+++
+++void ConsoleReporter::assertionEnded(AssertionStats const& _assertionStats) {
+++ AssertionResult const& result = _assertionStats.assertionResult;
+++
+++ bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+++
+++ // Drop out if result was successful but we're not printing them.
+++ // TODO: Make configurable whether skips should be printed
+++ if (!includeResults && result.getResultType() != ResultWas::Warning && result.getResultType() != ResultWas::ExplicitSkip)
+++ return;
+++
+++ lazyPrint();
+++
+++ ConsoleAssertionPrinter printer(m_stream, _assertionStats, m_colour.get(), includeResults);
+++ printer.print();
+++ m_stream << '\n' << std::flush;
+++}
+++
+++void ConsoleReporter::sectionStarting(SectionInfo const& _sectionInfo) {
+++ m_tablePrinter->close();
+++ m_headerPrinted = false;
+++ StreamingReporterBase::sectionStarting(_sectionInfo);
+++}
+++void ConsoleReporter::sectionEnded(SectionStats const& _sectionStats) {
+++ m_tablePrinter->close();
+++ if (_sectionStats.missingAssertions) {
+++ lazyPrint();
+++ auto guard =
+++ m_colour->guardColour( Colour::ResultError ).engage( m_stream );
+++ if (m_sectionStack.size() > 1)
+++ m_stream << "\nNo assertions in section";
+++ else
+++ m_stream << "\nNo assertions in test case";
+++ m_stream << " '" << _sectionStats.sectionInfo.name << "'\n\n" << std::flush;
+++ }
+++ double dur = _sectionStats.durationInSeconds;
+++ if (shouldShowDuration(*m_config, dur)) {
+++ m_stream << getFormattedDuration(dur) << " s: " << _sectionStats.sectionInfo.name << '\n' << std::flush;
+++ }
+++ if (m_headerPrinted) {
+++ m_headerPrinted = false;
+++ }
+++ StreamingReporterBase::sectionEnded(_sectionStats);
+++}
+++
+++void ConsoleReporter::benchmarkPreparing( StringRef name ) {
+++ lazyPrintWithoutClosingBenchmarkTable();
+++
+++ auto nameCol = TextFlow::Column( static_cast<std::string>( name ) )
+++ .width( m_tablePrinter->columnInfos()[0].width - 2 );
+++
+++ bool firstLine = true;
+++ for (auto line : nameCol) {
+++ if (!firstLine)
+++ (*m_tablePrinter) << ColumnBreak() << ColumnBreak() << ColumnBreak();
+++ else
+++ firstLine = false;
+++
+++ (*m_tablePrinter) << line << ColumnBreak();
+++ }
+++}
+++
+++void ConsoleReporter::benchmarkStarting(BenchmarkInfo const& info) {
+++ (*m_tablePrinter) << info.samples << ColumnBreak()
+++ << info.iterations << ColumnBreak();
+++ if ( !m_config->benchmarkNoAnalysis() ) {
+++ ( *m_tablePrinter )
+++ << Duration( info.estimatedDuration ) << ColumnBreak();
+++ }
+++ ( *m_tablePrinter ) << OutputFlush{};
+++}
+++void ConsoleReporter::benchmarkEnded(BenchmarkStats<> const& stats) {
+++ if (m_config->benchmarkNoAnalysis())
+++ {
+++ (*m_tablePrinter) << Duration(stats.mean.point.count()) << ColumnBreak();
+++ }
+++ else
+++ {
+++ (*m_tablePrinter) << ColumnBreak()
+++ << Duration(stats.mean.point.count()) << ColumnBreak()
+++ << Duration(stats.mean.lower_bound.count()) << ColumnBreak()
+++ << Duration(stats.mean.upper_bound.count()) << ColumnBreak() << ColumnBreak()
+++ << Duration(stats.standardDeviation.point.count()) << ColumnBreak()
+++ << Duration(stats.standardDeviation.lower_bound.count()) << ColumnBreak()
+++ << Duration(stats.standardDeviation.upper_bound.count()) << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak() << ColumnBreak();
+++ }
+++}
+++
+++void ConsoleReporter::benchmarkFailed( StringRef error ) {
+++ auto guard = m_colour->guardColour( Colour::Red ).engage( m_stream );
+++ (*m_tablePrinter)
+++ << "Benchmark failed (" << error << ')'
+++ << ColumnBreak() << RowBreak();
+++}
+++
+++void ConsoleReporter::testCaseEnded(TestCaseStats const& _testCaseStats) {
+++ m_tablePrinter->close();
+++ StreamingReporterBase::testCaseEnded(_testCaseStats);
+++ m_headerPrinted = false;
+++}
+++void ConsoleReporter::testRunEnded(TestRunStats const& _testRunStats) {
+++ printTotalsDivider(_testRunStats.totals);
+++ printTestRunTotals( m_stream, *m_colour, _testRunStats.totals );
+++ m_stream << '\n' << std::flush;
+++ StreamingReporterBase::testRunEnded(_testRunStats);
+++}
+++void ConsoleReporter::testRunStarting(TestRunInfo const& _testRunInfo) {
+++ StreamingReporterBase::testRunStarting(_testRunInfo);
+++ if ( m_config->testSpec().hasFilters() ) {
+++ m_stream << m_colour->guardColour( Colour::BrightYellow ) << "Filters: "
+++ << m_config->testSpec() << '\n';
+++ }
+++ m_stream << "Randomness seeded to: " << getSeed() << '\n';
+++}
+++
+++void ConsoleReporter::lazyPrint() {
+++
+++ m_tablePrinter->close();
+++ lazyPrintWithoutClosingBenchmarkTable();
+++}
+++
+++void ConsoleReporter::lazyPrintWithoutClosingBenchmarkTable() {
+++
+++ if ( !m_testRunInfoPrinted ) {
+++ lazyPrintRunInfo();
+++ }
+++ if (!m_headerPrinted) {
+++ printTestCaseAndSectionHeader();
+++ m_headerPrinted = true;
+++ }
+++}
+++void ConsoleReporter::lazyPrintRunInfo() {
+++ m_stream << '\n'
+++ << lineOfChars( '~' ) << '\n'
+++ << m_colour->guardColour( Colour::SecondaryText )
+++ << currentTestRunInfo.name << " is a Catch2 v" << libraryVersion()
+++ << " host application.\n"
+++ << "Run with -? for options\n\n";
+++
+++ m_testRunInfoPrinted = true;
+++}
+++void ConsoleReporter::printTestCaseAndSectionHeader() {
+++ assert(!m_sectionStack.empty());
+++ printOpenHeader(currentTestCaseInfo->name);
+++
+++ if (m_sectionStack.size() > 1) {
+++ auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream );
+++
+++ auto
+++ it = m_sectionStack.begin() + 1, // Skip first section (test case)
+++ itEnd = m_sectionStack.end();
+++ for (; it != itEnd; ++it)
+++ printHeaderString(it->name, 2);
+++ }
+++
+++ SourceLineInfo lineInfo = m_sectionStack.back().lineInfo;
+++
+++
+++ m_stream << lineOfChars( '-' ) << '\n'
+++ << m_colour->guardColour( Colour::FileName ) << lineInfo << '\n'
+++ << lineOfChars( '.' ) << "\n\n"
+++ << std::flush;
+++}
+++
+++void ConsoleReporter::printClosedHeader(std::string const& _name) {
+++ printOpenHeader(_name);
+++ m_stream << lineOfChars('.') << '\n';
+++}
+++void ConsoleReporter::printOpenHeader(std::string const& _name) {
+++ m_stream << lineOfChars('-') << '\n';
+++ {
+++ auto guard = m_colour->guardColour( Colour::Headers ).engage( m_stream );
+++ printHeaderString(_name);
+++ }
+++}
+++
+++void ConsoleReporter::printHeaderString(std::string const& _string, std::size_t indent) {
+++ // We want to get a bit fancy with line breaking here, so that subsequent
+++ // lines start after ":" if one is present, e.g.
+++ // ```
+++ // blablabla: Fancy
+++ // linebreaking
+++ // ```
+++ // but we also want to avoid problems with overly long indentation causing
+++ // the text to take up too many lines, e.g.
+++ // ```
+++ // blablabla: F
+++ // a
+++ // n
+++ // c
+++ // y
+++ // .
+++ // .
+++ // .
+++ // ```
+++ // So we limit the prefix indentation check to first quarter of the possible
+++ // width
+++ std::size_t idx = _string.find( ": " );
+++ if ( idx != std::string::npos && idx < CATCH_CONFIG_CONSOLE_WIDTH / 4 ) {
+++ idx += 2;
+++ } else {
+++ idx = 0;
+++ }
+++ m_stream << TextFlow::Column( _string )
+++ .indent( indent + idx )
+++ .initialIndent( indent )
+++ << '\n';
+++}
+++
+++void ConsoleReporter::printTotalsDivider(Totals const& totals) {
+++ if (totals.testCases.total() > 0) {
+++ std::size_t failedRatio = makeRatio(totals.testCases.failed, totals.testCases.total());
+++ std::size_t failedButOkRatio = makeRatio(totals.testCases.failedButOk, totals.testCases.total());
+++ std::size_t passedRatio = makeRatio(totals.testCases.passed, totals.testCases.total());
+++ std::size_t skippedRatio = makeRatio(totals.testCases.skipped, totals.testCases.total());
+++ while (failedRatio + failedButOkRatio + passedRatio + skippedRatio < CATCH_CONFIG_CONSOLE_WIDTH - 1)
+++ findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)++;
+++ while (failedRatio + failedButOkRatio + passedRatio > CATCH_CONFIG_CONSOLE_WIDTH - 1)
+++ findMax(failedRatio, failedButOkRatio, passedRatio, skippedRatio)--;
+++
+++ m_stream << m_colour->guardColour( Colour::Error )
+++ << std::string( failedRatio, '=' )
+++ << m_colour->guardColour( Colour::ResultExpectedFailure )
+++ << std::string( failedButOkRatio, '=' );
+++ if ( totals.testCases.allPassed() ) {
+++ m_stream << m_colour->guardColour( Colour::ResultSuccess )
+++ << std::string( passedRatio, '=' );
+++ } else {
+++ m_stream << m_colour->guardColour( Colour::Success )
+++ << std::string( passedRatio, '=' );
+++ }
+++ m_stream << m_colour->guardColour( Colour::Skip )
+++ << std::string( skippedRatio, '=' );
+++ } else {
+++ m_stream << m_colour->guardColour( Colour::Warning )
+++ << std::string( CATCH_CONFIG_CONSOLE_WIDTH - 1, '=' );
+++ }
+++ m_stream << '\n';
+++}
+++
+++} // end namespace Catch
+++
+++#if defined(_MSC_VER)
+++#pragma warning(pop)
+++#endif
+++
+++#if defined(__clang__)
+++# pragma clang diagnostic pop
+++#endif
+++
+++
+++
+++
+++#include <algorithm>
+++#include <cassert>
+++
+++namespace Catch {
+++ namespace {
+++ struct BySectionInfo {
+++ BySectionInfo( SectionInfo const& other ): m_other( other ) {}
+++ BySectionInfo( BySectionInfo const& other ) = default;
+++ bool operator()(
+++ Detail::unique_ptr<CumulativeReporterBase::SectionNode> const&
+++ node ) const {
+++ return (
+++ ( node->stats.sectionInfo.name == m_other.name ) &&
+++ ( node->stats.sectionInfo.lineInfo == m_other.lineInfo ) );
+++ }
+++ void operator=( BySectionInfo const& ) = delete;
+++
+++ private:
+++ SectionInfo const& m_other;
+++ };
+++
+++ } // namespace
+++
+++ namespace Detail {
+++ AssertionOrBenchmarkResult::AssertionOrBenchmarkResult(
+++ AssertionStats const& assertion ):
+++ m_assertion( assertion ) {}
+++
+++ AssertionOrBenchmarkResult::AssertionOrBenchmarkResult(
+++ BenchmarkStats<> const& benchmark ):
+++ m_benchmark( benchmark ) {}
+++
+++ bool AssertionOrBenchmarkResult::isAssertion() const {
+++ return m_assertion.some();
+++ }
+++ bool AssertionOrBenchmarkResult::isBenchmark() const {
+++ return m_benchmark.some();
+++ }
+++
+++ AssertionStats const& AssertionOrBenchmarkResult::asAssertion() const {
+++ assert(m_assertion.some());
+++
+++ return *m_assertion;
+++ }
+++ BenchmarkStats<> const& AssertionOrBenchmarkResult::asBenchmark() const {
+++ assert(m_benchmark.some());
+++
+++ return *m_benchmark;
+++ }
+++
+++ }
+++
+++ CumulativeReporterBase::~CumulativeReporterBase() = default;
+++
+++ void CumulativeReporterBase::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
+++ m_sectionStack.back()->assertionsAndBenchmarks.emplace_back(benchmarkStats);
+++ }
+++
+++ void
+++ CumulativeReporterBase::sectionStarting( SectionInfo const& sectionInfo ) {
+++ // We need a copy, because SectionStats expect to take ownership
+++ SectionStats incompleteStats( SectionInfo(sectionInfo), Counts(), 0, false );
+++ SectionNode* node;
+++ if ( m_sectionStack.empty() ) {
+++ if ( !m_rootSection ) {
+++ m_rootSection =
+++ Detail::make_unique<SectionNode>( incompleteStats );
+++ }
+++ node = m_rootSection.get();
+++ } else {
+++ SectionNode& parentNode = *m_sectionStack.back();
+++ auto it = std::find_if( parentNode.childSections.begin(),
+++ parentNode.childSections.end(),
+++ BySectionInfo( sectionInfo ) );
+++ if ( it == parentNode.childSections.end() ) {
+++ auto newNode =
+++ Detail::make_unique<SectionNode>( incompleteStats );
+++ node = newNode.get();
+++ parentNode.childSections.push_back( CATCH_MOVE( newNode ) );
+++ } else {
+++ node = it->get();
+++ }
+++ }
+++
+++ m_deepestSection = node;
+++ m_sectionStack.push_back( node );
+++ }
+++
+++ void CumulativeReporterBase::assertionEnded(
+++ AssertionStats const& assertionStats ) {
+++ assert( !m_sectionStack.empty() );
+++ // AssertionResult holds a pointer to a temporary DecomposedExpression,
+++ // which getExpandedExpression() calls to build the expression string.
+++ // Our section stack copy of the assertionResult will likely outlive the
+++ // temporary, so it must be expanded or discarded now to avoid calling
+++ // a destroyed object later.
+++ if ( m_shouldStoreFailedAssertions &&
+++ !assertionStats.assertionResult.isOk() ) {
+++ static_cast<void>(
+++ assertionStats.assertionResult.getExpandedExpression() );
+++ }
+++ if ( m_shouldStoreSuccesfulAssertions &&
+++ assertionStats.assertionResult.isOk() ) {
+++ static_cast<void>(
+++ assertionStats.assertionResult.getExpandedExpression() );
+++ }
+++ SectionNode& sectionNode = *m_sectionStack.back();
+++ sectionNode.assertionsAndBenchmarks.emplace_back( assertionStats );
+++ }
+++
+++ void CumulativeReporterBase::sectionEnded( SectionStats const& sectionStats ) {
+++ assert( !m_sectionStack.empty() );
+++ SectionNode& node = *m_sectionStack.back();
+++ node.stats = sectionStats;
+++ m_sectionStack.pop_back();
+++ }
+++
+++ void CumulativeReporterBase::testCaseEnded(
+++ TestCaseStats const& testCaseStats ) {
+++ auto node = Detail::make_unique<TestCaseNode>( testCaseStats );
+++ assert( m_sectionStack.size() == 0 );
+++ node->children.push_back( CATCH_MOVE(m_rootSection) );
+++ m_testCases.push_back( CATCH_MOVE(node) );
+++
+++ assert( m_deepestSection );
+++ m_deepestSection->stdOut = testCaseStats.stdOut;
+++ m_deepestSection->stdErr = testCaseStats.stdErr;
+++ }
+++
+++
+++ void CumulativeReporterBase::testRunEnded( TestRunStats const& testRunStats ) {
+++ assert(!m_testRun && "CumulativeReporterBase assumes there can only be one test run");
+++ m_testRun = Detail::make_unique<TestRunNode>( testRunStats );
+++ m_testRun->children.swap( m_testCases );
+++ testRunEndedCumulative();
+++ }
+++
+++ bool CumulativeReporterBase::SectionNode::hasAnyAssertions() const {
+++ return std::any_of(
+++ assertionsAndBenchmarks.begin(),
+++ assertionsAndBenchmarks.end(),
+++ []( Detail::AssertionOrBenchmarkResult const& res ) {
+++ return res.isAssertion();
+++ } );
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++namespace Catch {
+++
+++ void EventListenerBase::fatalErrorEncountered( StringRef ) {}
+++
+++ void EventListenerBase::benchmarkPreparing( StringRef ) {}
+++ void EventListenerBase::benchmarkStarting( BenchmarkInfo const& ) {}
+++ void EventListenerBase::benchmarkEnded( BenchmarkStats<> const& ) {}
+++ void EventListenerBase::benchmarkFailed( StringRef ) {}
+++
+++ void EventListenerBase::assertionStarting( AssertionInfo const& ) {}
+++
+++ void EventListenerBase::assertionEnded( AssertionStats const& ) {}
+++ void EventListenerBase::listReporters(
+++ std::vector<ReporterDescription> const& ) {}
+++ void EventListenerBase::listListeners(
+++ std::vector<ListenerDescription> const& ) {}
+++ void EventListenerBase::listTests( std::vector<TestCaseHandle> const& ) {}
+++ void EventListenerBase::listTags( std::vector<TagInfo> const& ) {}
+++ void EventListenerBase::noMatchingTestCases( StringRef ) {}
+++ void EventListenerBase::reportInvalidTestSpec( StringRef ) {}
+++ void EventListenerBase::testRunStarting( TestRunInfo const& ) {}
+++ void EventListenerBase::testCaseStarting( TestCaseInfo const& ) {}
+++ void EventListenerBase::testCasePartialStarting(TestCaseInfo const&, uint64_t) {}
+++ void EventListenerBase::sectionStarting( SectionInfo const& ) {}
+++ void EventListenerBase::sectionEnded( SectionStats const& ) {}
+++ void EventListenerBase::testCasePartialEnded(TestCaseStats const&, uint64_t) {}
+++ void EventListenerBase::testCaseEnded( TestCaseStats const& ) {}
+++ void EventListenerBase::testRunEnded( TestRunStats const& ) {}
+++ void EventListenerBase::skipTest( TestCaseInfo const& ) {}
+++} // namespace Catch
+++
+++
+++
+++
+++#include <algorithm>
+++#include <cfloat>
+++#include <cstdio>
+++#include <ostream>
+++#include <iomanip>
+++
+++namespace Catch {
+++
+++ namespace {
+++ void listTestNamesOnly(std::ostream& out,
+++ std::vector<TestCaseHandle> const& tests) {
+++ for (auto const& test : tests) {
+++ auto const& testCaseInfo = test.getTestCaseInfo();
+++
+++ if (startsWith(testCaseInfo.name, '#')) {
+++ out << '"' << testCaseInfo.name << '"';
+++ } else {
+++ out << testCaseInfo.name;
+++ }
+++
+++ out << '\n';
+++ }
+++ out << std::flush;
+++ }
+++ } // end unnamed namespace
+++
+++
+++ // Because formatting using c++ streams is stateful, drop down to C is
+++ // required Alternatively we could use stringstream, but its performance
+++ // is... not good.
+++ std::string getFormattedDuration( double duration ) {
+++ // Max exponent + 1 is required to represent the whole part
+++ // + 1 for decimal point
+++ // + 3 for the 3 decimal places
+++ // + 1 for null terminator
+++ const std::size_t maxDoubleSize = DBL_MAX_10_EXP + 1 + 1 + 3 + 1;
+++ char buffer[maxDoubleSize];
+++
+++ // Save previous errno, to prevent sprintf from overwriting it
+++ ErrnoGuard guard;
+++#ifdef _MSC_VER
+++ size_t printedLength = static_cast<size_t>(
+++ sprintf_s( buffer, "%.3f", duration ) );
+++#else
+++ size_t printedLength = static_cast<size_t>(
+++ std::snprintf( buffer, maxDoubleSize, "%.3f", duration ) );
+++#endif
+++ return std::string( buffer, printedLength );
+++ }
+++
+++ bool shouldShowDuration( IConfig const& config, double duration ) {
+++ if ( config.showDurations() == ShowDurations::Always ) {
+++ return true;
+++ }
+++ if ( config.showDurations() == ShowDurations::Never ) {
+++ return false;
+++ }
+++ const double min = config.minDuration();
+++ return min >= 0 && duration >= min;
+++ }
+++
+++ std::string serializeFilters( std::vector<std::string> const& filters ) {
+++ // We add a ' ' separator between each filter
+++ size_t serialized_size = filters.size() - 1;
+++ for (auto const& filter : filters) {
+++ serialized_size += filter.size();
+++ }
+++
+++ std::string serialized;
+++ serialized.reserve(serialized_size);
+++ bool first = true;
+++
+++ for (auto const& filter : filters) {
+++ if (!first) {
+++ serialized.push_back(' ');
+++ }
+++ first = false;
+++ serialized.append(filter);
+++ }
+++
+++ return serialized;
+++ }
+++
+++ std::ostream& operator<<( std::ostream& out, lineOfChars value ) {
+++ for ( size_t idx = 0; idx < CATCH_CONFIG_CONSOLE_WIDTH - 1; ++idx ) {
+++ out.put( value.c );
+++ }
+++ return out;
+++ }
+++
+++ void
+++ defaultListReporters( std::ostream& out,
+++ std::vector<ReporterDescription> const& descriptions,
+++ Verbosity verbosity ) {
+++ out << "Available reporters:\n";
+++ const auto maxNameLen =
+++ std::max_element( descriptions.begin(),
+++ descriptions.end(),
+++ []( ReporterDescription const& lhs,
+++ ReporterDescription const& rhs ) {
+++ return lhs.name.size() < rhs.name.size();
+++ } )
+++ ->name.size();
+++
+++ for ( auto const& desc : descriptions ) {
+++ if ( verbosity == Verbosity::Quiet ) {
+++ out << TextFlow::Column( desc.name )
+++ .indent( 2 )
+++ .width( 5 + maxNameLen )
+++ << '\n';
+++ } else {
+++ out << TextFlow::Column( desc.name + ':' )
+++ .indent( 2 )
+++ .width( 5 + maxNameLen ) +
+++ TextFlow::Column( desc.description )
+++ .initialIndent( 0 )
+++ .indent( 2 )
+++ .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 )
+++ << '\n';
+++ }
+++ }
+++ out << '\n' << std::flush;
+++ }
+++
+++ void defaultListListeners( std::ostream& out,
+++ std::vector<ListenerDescription> const& descriptions ) {
+++ out << "Registered listeners:\n";
+++
+++ if(descriptions.empty()) {
+++ return;
+++ }
+++
+++ const auto maxNameLen =
+++ std::max_element( descriptions.begin(),
+++ descriptions.end(),
+++ []( ListenerDescription const& lhs,
+++ ListenerDescription const& rhs ) {
+++ return lhs.name.size() < rhs.name.size();
+++ } )
+++ ->name.size();
+++
+++ for ( auto const& desc : descriptions ) {
+++ out << TextFlow::Column( static_cast<std::string>( desc.name ) +
+++ ':' )
+++ .indent( 2 )
+++ .width( maxNameLen + 5 ) +
+++ TextFlow::Column( desc.description )
+++ .initialIndent( 0 )
+++ .indent( 2 )
+++ .width( CATCH_CONFIG_CONSOLE_WIDTH - maxNameLen - 8 )
+++ << '\n';
+++ }
+++
+++ out << '\n' << std::flush;
+++ }
+++
+++ void defaultListTags( std::ostream& out,
+++ std::vector<TagInfo> const& tags,
+++ bool isFiltered ) {
+++ if ( isFiltered ) {
+++ out << "Tags for matching test cases:\n";
+++ } else {
+++ out << "All available tags:\n";
+++ }
+++
+++ for ( auto const& tagCount : tags ) {
+++ ReusableStringStream rss;
+++ rss << " " << std::setw( 2 ) << tagCount.count << " ";
+++ auto str = rss.str();
+++ auto wrapper = TextFlow::Column( tagCount.all() )
+++ .initialIndent( 0 )
+++ .indent( str.size() )
+++ .width( CATCH_CONFIG_CONSOLE_WIDTH - 10 );
+++ out << str << wrapper << '\n';
+++ }
+++ out << pluralise(tags.size(), "tag"_sr) << "\n\n" << std::flush;
+++ }
+++
+++ void defaultListTests(std::ostream& out, ColourImpl* streamColour, std::vector<TestCaseHandle> const& tests, bool isFiltered, Verbosity verbosity) {
+++ // We special case this to provide the equivalent of old
+++ // `--list-test-names-only`, which could then be used by the
+++ // `--input-file` option.
+++ if (verbosity == Verbosity::Quiet) {
+++ listTestNamesOnly(out, tests);
+++ return;
+++ }
+++
+++ if (isFiltered) {
+++ out << "Matching test cases:\n";
+++ } else {
+++ out << "All available test cases:\n";
+++ }
+++
+++ for (auto const& test : tests) {
+++ auto const& testCaseInfo = test.getTestCaseInfo();
+++ Colour::Code colour = testCaseInfo.isHidden()
+++ ? Colour::SecondaryText
+++ : Colour::None;
+++ auto colourGuard = streamColour->guardColour( colour ).engage( out );
+++
+++ out << TextFlow::Column(testCaseInfo.name).indent(2) << '\n';
+++ if (verbosity >= Verbosity::High) {
+++ out << TextFlow::Column(Catch::Detail::stringify(testCaseInfo.lineInfo)).indent(4) << '\n';
+++ }
+++ if (!testCaseInfo.tags.empty() &&
+++ verbosity > Verbosity::Quiet) {
+++ out << TextFlow::Column(testCaseInfo.tagsAsString()).indent(6) << '\n';
+++ }
+++ }
+++
+++ if (isFiltered) {
+++ out << pluralise(tests.size(), "matching test case"_sr);
+++ } else {
+++ out << pluralise(tests.size(), "test case"_sr);
+++ }
+++ out << "\n\n" << std::flush;
+++ }
+++
+++ namespace {
+++ class SummaryColumn {
+++ public:
+++ SummaryColumn( std::string suffix, Colour::Code colour ):
+++ m_suffix( CATCH_MOVE( suffix ) ), m_colour( colour ) {}
+++
+++ SummaryColumn&& addRow( std::uint64_t count ) && {
+++ std::string row = std::to_string(count);
+++ auto const new_width = std::max( m_width, row.size() );
+++ if ( new_width > m_width ) {
+++ for ( auto& oldRow : m_rows ) {
+++ oldRow.insert( 0, new_width - m_width, ' ' );
+++ }
+++ } else {
+++ row.insert( 0, m_width - row.size(), ' ' );
+++ }
+++ m_width = new_width;
+++ m_rows.push_back( row );
+++ return std::move( *this );
+++ }
+++
+++ std::string const& getSuffix() const { return m_suffix; }
+++ Colour::Code getColour() const { return m_colour; }
+++ std::string const& getRow( std::size_t index ) const {
+++ return m_rows[index];
+++ }
+++
+++ private:
+++ std::string m_suffix;
+++ Colour::Code m_colour;
+++ std::size_t m_width = 0;
+++ std::vector<std::string> m_rows;
+++ };
+++
+++ void printSummaryRow( std::ostream& stream,
+++ ColourImpl& colour,
+++ StringRef label,
+++ std::vector<SummaryColumn> const& cols,
+++ std::size_t row ) {
+++ for ( auto const& col : cols ) {
+++ auto const& value = col.getRow( row );
+++ auto const& suffix = col.getSuffix();
+++ if ( suffix.empty() ) {
+++ stream << label << ": ";
+++ if ( value != "0" ) {
+++ stream << value;
+++ } else {
+++ stream << colour.guardColour( Colour::Warning )
+++ << "- none -";
+++ }
+++ } else if ( value != "0" ) {
+++ stream << colour.guardColour( Colour::LightGrey ) << " | "
+++ << colour.guardColour( col.getColour() ) << value
+++ << ' ' << suffix;
+++ }
+++ }
+++ stream << '\n';
+++ }
+++ } // namespace
+++
+++ void printTestRunTotals( std::ostream& stream,
+++ ColourImpl& streamColour,
+++ Totals const& totals ) {
+++ if ( totals.testCases.total() == 0 ) {
+++ stream << streamColour.guardColour( Colour::Warning )
+++ << "No tests ran\n";
+++ return;
+++ }
+++
+++ if ( totals.assertions.total() > 0 && totals.testCases.allPassed() ) {
+++ stream << streamColour.guardColour( Colour::ResultSuccess )
+++ << "All tests passed";
+++ stream << " ("
+++ << pluralise( totals.assertions.passed, "assertion"_sr )
+++ << " in "
+++ << pluralise( totals.testCases.passed, "test case"_sr )
+++ << ')' << '\n';
+++ return;
+++ }
+++
+++ std::vector<SummaryColumn> columns;
+++ // Don't include "skipped assertions" in total count
+++ const auto totalAssertionCount =
+++ totals.assertions.total() - totals.assertions.skipped;
+++ columns.push_back( SummaryColumn( "", Colour::None )
+++ .addRow( totals.testCases.total() )
+++ .addRow( totalAssertionCount ) );
+++ columns.push_back( SummaryColumn( "passed", Colour::Success )
+++ .addRow( totals.testCases.passed )
+++ .addRow( totals.assertions.passed ) );
+++ columns.push_back( SummaryColumn( "failed", Colour::ResultError )
+++ .addRow( totals.testCases.failed )
+++ .addRow( totals.assertions.failed ) );
+++ columns.push_back( SummaryColumn( "skipped", Colour::Skip )
+++ .addRow( totals.testCases.skipped )
+++ // Don't print "skipped assertions"
+++ .addRow( 0 ) );
+++ columns.push_back(
+++ SummaryColumn( "failed as expected", Colour::ResultExpectedFailure )
+++ .addRow( totals.testCases.failedButOk )
+++ .addRow( totals.assertions.failedButOk ) );
+++ printSummaryRow( stream, streamColour, "test cases"_sr, columns, 0 );
+++ printSummaryRow( stream, streamColour, "assertions"_sr, columns, 1 );
+++ }
+++
+++} // namespace Catch
+++
+++
+++//
+++
+++namespace Catch {
+++ namespace {
+++ void writeSourceInfo( JsonObjectWriter& writer,
+++ SourceLineInfo const& sourceInfo ) {
+++ auto source_location_writer =
+++ writer.write( "source-location"_sr ).writeObject();
+++ source_location_writer.write( "filename"_sr )
+++ .write( sourceInfo.file );
+++ source_location_writer.write( "line"_sr ).write( sourceInfo.line );
+++ }
+++
+++ void writeTags( JsonArrayWriter writer, std::vector<Tag> const& tags ) {
+++ for ( auto const& tag : tags ) {
+++ writer.write( tag.original );
+++ }
+++ }
+++
+++ void writeProperties( JsonArrayWriter writer,
+++ TestCaseInfo const& info ) {
+++ if ( info.isHidden() ) { writer.write( "is-hidden"_sr ); }
+++ if ( info.okToFail() ) { writer.write( "ok-to-fail"_sr ); }
+++ if ( info.expectedToFail() ) {
+++ writer.write( "expected-to-fail"_sr );
+++ }
+++ if ( info.throws() ) { writer.write( "throws"_sr ); }
+++ }
+++
+++ } // namespace
+++
+++ JsonReporter::JsonReporter( ReporterConfig&& config ):
+++ StreamingReporterBase{ CATCH_MOVE( config ) } {
+++
+++ m_preferences.shouldRedirectStdOut = true;
+++ // TBD: Do we want to report all assertions? XML reporter does
+++ // not, but for machine-parseable reporters I think the answer
+++ // should be yes.
+++ m_preferences.shouldReportAllAssertions = true;
+++
+++ m_objectWriters.emplace( m_stream );
+++ m_writers.emplace( Writer::Object );
+++ auto& writer = m_objectWriters.top();
+++
+++ writer.write( "version"_sr ).write( 1 );
+++
+++ {
+++ auto metadata_writer = writer.write( "metadata"_sr ).writeObject();
+++ metadata_writer.write( "name"_sr ).write( m_config->name() );
+++ metadata_writer.write( "rng-seed"_sr ).write( m_config->rngSeed() );
+++ metadata_writer.write( "catch2-version"_sr )
+++ .write( libraryVersion() );
+++ if ( m_config->testSpec().hasFilters() ) {
+++ metadata_writer.write( "filters"_sr )
+++ .write( m_config->testSpec() );
+++ }
+++ }
+++ }
+++
+++ JsonReporter::~JsonReporter() {
+++ endListing();
+++ // TODO: Ensure this closes the top level object, add asserts
+++ assert( m_writers.size() == 1 && "Only the top level object should be open" );
+++ assert( m_writers.top() == Writer::Object );
+++ endObject();
+++ m_stream << '\n' << std::flush;
+++ assert( m_writers.empty() );
+++ }
+++
+++ JsonArrayWriter& JsonReporter::startArray() {
+++ m_arrayWriters.emplace( m_arrayWriters.top().writeArray() );
+++ m_writers.emplace( Writer::Array );
+++ return m_arrayWriters.top();
+++ }
+++ JsonArrayWriter& JsonReporter::startArray( StringRef key ) {
+++ m_arrayWriters.emplace(
+++ m_objectWriters.top().write( key ).writeArray() );
+++ m_writers.emplace( Writer::Array );
+++ return m_arrayWriters.top();
+++ }
+++
+++ JsonObjectWriter& JsonReporter::startObject() {
+++ m_objectWriters.emplace( m_arrayWriters.top().writeObject() );
+++ m_writers.emplace( Writer::Object );
+++ return m_objectWriters.top();
+++ }
+++ JsonObjectWriter& JsonReporter::startObject( StringRef key ) {
+++ m_objectWriters.emplace(
+++ m_objectWriters.top().write( key ).writeObject() );
+++ m_writers.emplace( Writer::Object );
+++ return m_objectWriters.top();
+++ }
+++
+++ void JsonReporter::endObject() {
+++ assert( isInside( Writer::Object ) );
+++ m_objectWriters.pop();
+++ m_writers.pop();
+++ }
+++ void JsonReporter::endArray() {
+++ assert( isInside( Writer::Array ) );
+++ m_arrayWriters.pop();
+++ m_writers.pop();
+++ }
+++
+++ bool JsonReporter::isInside( Writer writer ) {
+++ return !m_writers.empty() && m_writers.top() == writer;
+++ }
+++
+++ void JsonReporter::startListing() {
+++ if ( !m_startedListing ) { startObject( "listings"_sr ); }
+++ m_startedListing = true;
+++ }
+++ void JsonReporter::endListing() {
+++ if ( m_startedListing ) { endObject(); }
+++ m_startedListing = false;
+++ }
+++
+++ std::string JsonReporter::getDescription() {
+++ return "Outputs listings as JSON. Test listing is Work-in-Progress!";
+++ }
+++
+++ void JsonReporter::testRunStarting( TestRunInfo const& runInfo ) {
+++ StreamingReporterBase::testRunStarting( runInfo );
+++ endListing();
+++
+++ assert( isInside( Writer::Object ) );
+++ startObject( "test-run"_sr );
+++ startArray( "test-cases"_sr );
+++ }
+++
+++ static void writeCounts( JsonObjectWriter&& writer, Counts const& counts ) {
+++ writer.write( "passed"_sr ).write( counts.passed );
+++ writer.write( "failed"_sr ).write( counts.failed );
+++ writer.write( "fail-but-ok"_sr ).write( counts.failedButOk );
+++ writer.write( "skipped"_sr ).write( counts.skipped );
+++ }
+++
+++ void JsonReporter::testRunEnded(TestRunStats const& runStats) {
+++ assert( isInside( Writer::Array ) );
+++ // End "test-cases"
+++ endArray();
+++
+++ {
+++ auto totals =
+++ m_objectWriters.top().write( "totals"_sr ).writeObject();
+++ writeCounts( totals.write( "assertions"_sr ).writeObject(),
+++ runStats.totals.assertions );
+++ writeCounts( totals.write( "test-cases"_sr ).writeObject(),
+++ runStats.totals.testCases );
+++ }
+++
+++ // End the "test-run" object
+++ endObject();
+++ }
+++
+++ void JsonReporter::testCaseStarting( TestCaseInfo const& tcInfo ) {
+++ StreamingReporterBase::testCaseStarting( tcInfo );
+++
+++ assert( isInside( Writer::Array ) &&
+++ "We should be in the 'test-cases' array" );
+++ startObject();
+++ // "test-info" prelude
+++ {
+++ auto testInfo =
+++ m_objectWriters.top().write( "test-info"_sr ).writeObject();
+++ // TODO: handle testName vs className!!
+++ testInfo.write( "name"_sr ).write( tcInfo.name );
+++ writeSourceInfo(testInfo, tcInfo.lineInfo);
+++ writeTags( testInfo.write( "tags"_sr ).writeArray(), tcInfo.tags );
+++ writeProperties( testInfo.write( "properties"_sr ).writeArray(),
+++ tcInfo );
+++ }
+++
+++
+++ // Start the array for individual test runs (testCasePartial pairs)
+++ startArray( "runs"_sr );
+++ }
+++
+++ void JsonReporter::testCaseEnded( TestCaseStats const& tcStats ) {
+++ StreamingReporterBase::testCaseEnded( tcStats );
+++
+++ // We need to close the 'runs' array before finishing the test case
+++ assert( isInside( Writer::Array ) );
+++ endArray();
+++
+++ {
+++ auto totals =
+++ m_objectWriters.top().write( "totals"_sr ).writeObject();
+++ writeCounts( totals.write( "assertions"_sr ).writeObject(),
+++ tcStats.totals.assertions );
+++ // We do not write the test case totals, because there will always be just one test case here.
+++ // TODO: overall "result" -> success, skip, fail here? Or in partial result?
+++ }
+++ // We do not write out stderr/stdout, because we instead wrote those out in partial runs
+++
+++ // TODO: aborting?
+++
+++ // And we also close this test case's object
+++ assert( isInside( Writer::Object ) );
+++ endObject();
+++ }
+++
+++ void JsonReporter::testCasePartialStarting( TestCaseInfo const& /*tcInfo*/,
+++ uint64_t index ) {
+++ startObject();
+++ m_objectWriters.top().write( "run-idx"_sr ).write( index );
+++ startArray( "path"_sr );
+++ // TODO: we want to delay most of the printing to the 'root' section
+++ // TODO: childSection key name?
+++ }
+++
+++ void JsonReporter::testCasePartialEnded( TestCaseStats const& tcStats,
+++ uint64_t /*index*/ ) {
+++ // Fixme: the top level section handles this.
+++ //// path object
+++ endArray();
+++ if ( !tcStats.stdOut.empty() ) {
+++ m_objectWriters.top()
+++ .write( "captured-stdout"_sr )
+++ .write( tcStats.stdOut );
+++ }
+++ if ( !tcStats.stdErr.empty() ) {
+++ m_objectWriters.top()
+++ .write( "captured-stderr"_sr )
+++ .write( tcStats.stdErr );
+++ }
+++ {
+++ auto totals =
+++ m_objectWriters.top().write( "totals"_sr ).writeObject();
+++ writeCounts( totals.write( "assertions"_sr ).writeObject(),
+++ tcStats.totals.assertions );
+++ // We do not write the test case totals, because there will
+++ // always be just one test case here.
+++ // TODO: overall "result" -> success, skip, fail here? Or in
+++ // partial result?
+++ }
+++ // TODO: aborting?
+++ // run object
+++ endObject();
+++ }
+++
+++ void JsonReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+++ assert( isInside( Writer::Array ) &&
+++ "Section should always start inside an object" );
+++ // We want to nest top level sections, even though it shares name
+++ // and source loc with the TEST_CASE
+++ auto& sectionObject = startObject();
+++ sectionObject.write( "kind"_sr ).write( "section"_sr );
+++ sectionObject.write( "name"_sr ).write( sectionInfo.name );
+++ writeSourceInfo( m_objectWriters.top(), sectionInfo.lineInfo );
+++
+++
+++ // TBD: Do we want to create this event lazily? It would become
+++ // rather complex, but we could do it, and it would look
+++ // better for empty sections. OTOH, empty sections should
+++ // be rare.
+++ startArray( "path"_sr );
+++ }
+++ void JsonReporter::sectionEnded( SectionStats const& /*sectionStats */) {
+++ // End the subpath array
+++ endArray();
+++ // TODO: metadata
+++ // TODO: what info do we have here?
+++
+++ // End the section object
+++ endObject();
+++ }
+++
+++ void JsonReporter::assertionStarting( AssertionInfo const& /*assertionInfo*/ ) {}
+++ void JsonReporter::assertionEnded( AssertionStats const& assertionStats ) {
+++ // TODO: There is lot of different things to handle here, but
+++ // we can fill it in later, after we show that the basic
+++ // outline and streaming reporter impl works well enough.
+++ //if ( !m_config->includeSuccessfulResults()
+++ // && assertionStats.assertionResult.isOk() ) {
+++ // return;
+++ //}
+++ assert( isInside( Writer::Array ) );
+++ auto assertionObject = m_arrayWriters.top().writeObject();
+++
+++ assertionObject.write( "kind"_sr ).write( "assertion"_sr );
+++ writeSourceInfo( assertionObject,
+++ assertionStats.assertionResult.getSourceInfo() );
+++ assertionObject.write( "status"_sr )
+++ .write( assertionStats.assertionResult.isOk() );
+++ // TODO: handling of result.
+++ // TODO: messages
+++ // TODO: totals?
+++ }
+++
+++
+++ void JsonReporter::benchmarkPreparing( StringRef name ) { (void)name; }
+++ void JsonReporter::benchmarkStarting( BenchmarkInfo const& ) {}
+++ void JsonReporter::benchmarkEnded( BenchmarkStats<> const& ) {}
+++ void JsonReporter::benchmarkFailed( StringRef error ) { (void)error; }
+++
+++ void JsonReporter::listReporters(
+++ std::vector<ReporterDescription> const& descriptions ) {
+++ startListing();
+++
+++ auto writer =
+++ m_objectWriters.top().write( "reporters"_sr ).writeArray();
+++ for ( auto const& desc : descriptions ) {
+++ auto desc_writer = writer.writeObject();
+++ desc_writer.write( "name"_sr ).write( desc.name );
+++ desc_writer.write( "description"_sr ).write( desc.description );
+++ }
+++ }
+++ void JsonReporter::listListeners(
+++ std::vector<ListenerDescription> const& descriptions ) {
+++ startListing();
+++
+++ auto writer =
+++ m_objectWriters.top().write( "listeners"_sr ).writeArray();
+++
+++ for ( auto const& desc : descriptions ) {
+++ auto desc_writer = writer.writeObject();
+++ desc_writer.write( "name"_sr ).write( desc.name );
+++ desc_writer.write( "description"_sr ).write( desc.description );
+++ }
+++ }
+++ void JsonReporter::listTests( std::vector<TestCaseHandle> const& tests ) {
+++ startListing();
+++
+++ auto writer = m_objectWriters.top().write( "tests"_sr ).writeArray();
+++
+++ for ( auto const& test : tests ) {
+++ auto desc_writer = writer.writeObject();
+++ auto const& info = test.getTestCaseInfo();
+++
+++ desc_writer.write( "name"_sr ).write( info.name );
+++ desc_writer.write( "class-name"_sr ).write( info.className );
+++ {
+++ auto tag_writer = desc_writer.write( "tags"_sr ).writeArray();
+++ for ( auto const& tag : info.tags ) {
+++ tag_writer.write( tag.original );
+++ }
+++ }
+++ writeSourceInfo( desc_writer, info.lineInfo );
+++ }
+++ }
+++ void JsonReporter::listTags( std::vector<TagInfo> const& tags ) {
+++ startListing();
+++
+++ auto writer = m_objectWriters.top().write( "tags"_sr ).writeArray();
+++ for ( auto const& tag : tags ) {
+++ auto tag_writer = writer.writeObject();
+++ {
+++ auto aliases_writer =
+++ tag_writer.write( "aliases"_sr ).writeArray();
+++ for ( auto alias : tag.spellings ) {
+++ aliases_writer.write( alias );
+++ }
+++ }
+++ tag_writer.write( "count"_sr ).write( tag.count );
+++ }
+++ }
+++} // namespace Catch
+++
+++
+++
+++
+++#include <cassert>
+++#include <ctime>
+++#include <algorithm>
+++#include <iomanip>
+++
+++namespace Catch {
+++
+++ namespace {
+++ std::string getCurrentTimestamp() {
+++ time_t rawtime;
+++ std::time(&rawtime);
+++
+++ std::tm timeInfo = {};
+++#if defined (_MSC_VER) || defined (__MINGW32__)
+++ gmtime_s(&timeInfo, &rawtime);
+++#elif defined (CATCH_PLATFORM_PLAYSTATION)
+++ gmtime_s(&rawtime, &timeInfo);
+++#elif defined (__IAR_SYSTEMS_ICC__)
+++ timeInfo = *std::gmtime(&rawtime);
+++#else
+++ gmtime_r(&rawtime, &timeInfo);
+++#endif
+++
+++ auto const timeStampSize = sizeof("2017-01-16T17:06:45Z");
+++ char timeStamp[timeStampSize];
+++ const char * const fmt = "%Y-%m-%dT%H:%M:%SZ";
+++
+++ std::strftime(timeStamp, timeStampSize, fmt, &timeInfo);
+++
+++ return std::string(timeStamp, timeStampSize - 1);
+++ }
+++
+++ std::string fileNameTag(std::vector<Tag> const& tags) {
+++ auto it = std::find_if(begin(tags),
+++ end(tags),
+++ [] (Tag const& tag) {
+++ return tag.original.size() > 0
+++ && tag.original[0] == '#'; });
+++ if (it != tags.end()) {
+++ return static_cast<std::string>(
+++ it->original.substr(1, it->original.size() - 1)
+++ );
+++ }
+++ return std::string();
+++ }
+++
+++ // Formats the duration in seconds to 3 decimal places.
+++ // This is done because some genius defined Maven Surefire schema
+++ // in a way that only accepts 3 decimal places, and tools like
+++ // Jenkins use that schema for validation JUnit reporter output.
+++ std::string formatDuration( double seconds ) {
+++ ReusableStringStream rss;
+++ rss << std::fixed << std::setprecision( 3 ) << seconds;
+++ return rss.str();
+++ }
+++
+++ static void normalizeNamespaceMarkers(std::string& str) {
+++ std::size_t pos = str.find( "::" );
+++ while ( pos != std::string::npos ) {
+++ str.replace( pos, 2, "." );
+++ pos += 1;
+++ pos = str.find( "::", pos );
+++ }
+++ }
+++
+++ } // anonymous namespace
+++
+++ JunitReporter::JunitReporter( ReporterConfig&& _config )
+++ : CumulativeReporterBase( CATCH_MOVE(_config) ),
+++ xml( m_stream )
+++ {
+++ m_preferences.shouldRedirectStdOut = true;
+++ m_preferences.shouldReportAllAssertions = true;
+++ m_shouldStoreSuccesfulAssertions = false;
+++ }
+++
+++ std::string JunitReporter::getDescription() {
+++ return "Reports test results in an XML format that looks like Ant's junitreport target";
+++ }
+++
+++ void JunitReporter::testRunStarting( TestRunInfo const& runInfo ) {
+++ CumulativeReporterBase::testRunStarting( runInfo );
+++ xml.startElement( "testsuites" );
+++ suiteTimer.start();
+++ stdOutForSuite.clear();
+++ stdErrForSuite.clear();
+++ unexpectedExceptions = 0;
+++ }
+++
+++ void JunitReporter::testCaseStarting( TestCaseInfo const& testCaseInfo ) {
+++ m_okToFail = testCaseInfo.okToFail();
+++ }
+++
+++ void JunitReporter::assertionEnded( AssertionStats const& assertionStats ) {
+++ if( assertionStats.assertionResult.getResultType() == ResultWas::ThrewException && !m_okToFail )
+++ unexpectedExceptions++;
+++ CumulativeReporterBase::assertionEnded( assertionStats );
+++ }
+++
+++ void JunitReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+++ stdOutForSuite += testCaseStats.stdOut;
+++ stdErrForSuite += testCaseStats.stdErr;
+++ CumulativeReporterBase::testCaseEnded( testCaseStats );
+++ }
+++
+++ void JunitReporter::testRunEndedCumulative() {
+++ const auto suiteTime = suiteTimer.getElapsedSeconds();
+++ writeRun( *m_testRun, suiteTime );
+++ xml.endElement();
+++ }
+++
+++ void JunitReporter::writeRun( TestRunNode const& testRunNode, double suiteTime ) {
+++ XmlWriter::ScopedElement e = xml.scopedElement( "testsuite" );
+++
+++ TestRunStats const& stats = testRunNode.value;
+++ xml.writeAttribute( "name"_sr, stats.runInfo.name );
+++ xml.writeAttribute( "errors"_sr, unexpectedExceptions );
+++ xml.writeAttribute( "failures"_sr, stats.totals.assertions.failed-unexpectedExceptions );
+++ xml.writeAttribute( "skipped"_sr, stats.totals.assertions.skipped );
+++ xml.writeAttribute( "tests"_sr, stats.totals.assertions.total() );
+++ xml.writeAttribute( "hostname"_sr, "tbd"_sr ); // !TBD
+++ if( m_config->showDurations() == ShowDurations::Never )
+++ xml.writeAttribute( "time"_sr, ""_sr );
+++ else
+++ xml.writeAttribute( "time"_sr, formatDuration( suiteTime ) );
+++ xml.writeAttribute( "timestamp"_sr, getCurrentTimestamp() );
+++
+++ // Write properties
+++ {
+++ auto properties = xml.scopedElement("properties");
+++ xml.scopedElement("property")
+++ .writeAttribute("name"_sr, "random-seed"_sr)
+++ .writeAttribute("value"_sr, m_config->rngSeed());
+++ if (m_config->testSpec().hasFilters()) {
+++ xml.scopedElement("property")
+++ .writeAttribute("name"_sr, "filters"_sr)
+++ .writeAttribute("value"_sr, m_config->testSpec());
+++ }
+++ }
+++
+++ // Write test cases
+++ for( auto const& child : testRunNode.children )
+++ writeTestCase( *child );
+++
+++ xml.scopedElement( "system-out" ).writeText( trim( stdOutForSuite ), XmlFormatting::Newline );
+++ xml.scopedElement( "system-err" ).writeText( trim( stdErrForSuite ), XmlFormatting::Newline );
+++ }
+++
+++ void JunitReporter::writeTestCase( TestCaseNode const& testCaseNode ) {
+++ TestCaseStats const& stats = testCaseNode.value;
+++
+++ // All test cases have exactly one section - which represents the
+++ // test case itself. That section may have 0-n nested sections
+++ assert( testCaseNode.children.size() == 1 );
+++ SectionNode const& rootSection = *testCaseNode.children.front();
+++
+++ std::string className =
+++ static_cast<std::string>( stats.testInfo->className );
+++
+++ if( className.empty() ) {
+++ className = fileNameTag(stats.testInfo->tags);
+++ if ( className.empty() ) {
+++ className = "global";
+++ }
+++ }
+++
+++ if ( !m_config->name().empty() )
+++ className = static_cast<std::string>(m_config->name()) + '.' + className;
+++
+++ normalizeNamespaceMarkers(className);
+++
+++ writeSection( className, "", rootSection, stats.testInfo->okToFail() );
+++ }
+++
+++ void JunitReporter::writeSection( std::string const& className,
+++ std::string const& rootName,
+++ SectionNode const& sectionNode,
+++ bool testOkToFail) {
+++ std::string name = trim( sectionNode.stats.sectionInfo.name );
+++ if( !rootName.empty() )
+++ name = rootName + '/' + name;
+++
+++ if( sectionNode.hasAnyAssertions()
+++ || !sectionNode.stdOut.empty()
+++ || !sectionNode.stdErr.empty() ) {
+++ XmlWriter::ScopedElement e = xml.scopedElement( "testcase" );
+++ if( className.empty() ) {
+++ xml.writeAttribute( "classname"_sr, name );
+++ xml.writeAttribute( "name"_sr, "root"_sr );
+++ }
+++ else {
+++ xml.writeAttribute( "classname"_sr, className );
+++ xml.writeAttribute( "name"_sr, name );
+++ }
+++ xml.writeAttribute( "time"_sr, formatDuration( sectionNode.stats.durationInSeconds ) );
+++ // This is not ideal, but it should be enough to mimic gtest's
+++ // junit output.
+++ // Ideally the JUnit reporter would also handle `skipTest`
+++ // events and write those out appropriately.
+++ xml.writeAttribute( "status"_sr, "run"_sr );
+++
+++ if (sectionNode.stats.assertions.failedButOk) {
+++ xml.scopedElement("skipped")
+++ .writeAttribute("message", "TEST_CASE tagged with !mayfail");
+++ }
+++
+++ writeAssertions( sectionNode );
+++
+++
+++ if( !sectionNode.stdOut.empty() )
+++ xml.scopedElement( "system-out" ).writeText( trim( sectionNode.stdOut ), XmlFormatting::Newline );
+++ if( !sectionNode.stdErr.empty() )
+++ xml.scopedElement( "system-err" ).writeText( trim( sectionNode.stdErr ), XmlFormatting::Newline );
+++ }
+++ for( auto const& childNode : sectionNode.childSections )
+++ if( className.empty() )
+++ writeSection( name, "", *childNode, testOkToFail );
+++ else
+++ writeSection( className, name, *childNode, testOkToFail );
+++ }
+++
+++ void JunitReporter::writeAssertions( SectionNode const& sectionNode ) {
+++ for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) {
+++ if (assertionOrBenchmark.isAssertion()) {
+++ writeAssertion(assertionOrBenchmark.asAssertion());
+++ }
+++ }
+++ }
+++
+++ void JunitReporter::writeAssertion( AssertionStats const& stats ) {
+++ AssertionResult const& result = stats.assertionResult;
+++ if ( !result.isOk() ||
+++ result.getResultType() == ResultWas::ExplicitSkip ) {
+++ std::string elementName;
+++ switch( result.getResultType() ) {
+++ case ResultWas::ThrewException:
+++ case ResultWas::FatalErrorCondition:
+++ elementName = "error";
+++ break;
+++ case ResultWas::ExplicitFailure:
+++ case ResultWas::ExpressionFailed:
+++ case ResultWas::DidntThrowException:
+++ elementName = "failure";
+++ break;
+++ case ResultWas::ExplicitSkip:
+++ elementName = "skipped";
+++ break;
+++ // We should never see these here:
+++ case ResultWas::Info:
+++ case ResultWas::Warning:
+++ case ResultWas::Ok:
+++ case ResultWas::Unknown:
+++ case ResultWas::FailureBit:
+++ case ResultWas::Exception:
+++ elementName = "internalError";
+++ break;
+++ }
+++
+++ XmlWriter::ScopedElement e = xml.scopedElement( elementName );
+++
+++ xml.writeAttribute( "message"_sr, result.getExpression() );
+++ xml.writeAttribute( "type"_sr, result.getTestMacroName() );
+++
+++ ReusableStringStream rss;
+++ if ( result.getResultType() == ResultWas::ExplicitSkip ) {
+++ rss << "SKIPPED\n";
+++ } else {
+++ rss << "FAILED" << ":\n";
+++ if (result.hasExpression()) {
+++ rss << " ";
+++ rss << result.getExpressionInMacro();
+++ rss << '\n';
+++ }
+++ if (result.hasExpandedExpression()) {
+++ rss << "with expansion:\n";
+++ rss << TextFlow::Column(result.getExpandedExpression()).indent(2) << '\n';
+++ }
+++ }
+++
+++ if( result.hasMessage() )
+++ rss << result.getMessage() << '\n';
+++ for( auto const& msg : stats.infoMessages )
+++ if( msg.type == ResultWas::Info )
+++ rss << msg.message << '\n';
+++
+++ rss << "at " << result.getSourceInfo();
+++ xml.writeText( rss.str(), XmlFormatting::Newline );
+++ }
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++#include <ostream>
+++
+++namespace Catch {
+++ void MultiReporter::updatePreferences(IEventListener const& reporterish) {
+++ m_preferences.shouldRedirectStdOut |=
+++ reporterish.getPreferences().shouldRedirectStdOut;
+++ m_preferences.shouldReportAllAssertions |=
+++ reporterish.getPreferences().shouldReportAllAssertions;
+++ }
+++
+++ void MultiReporter::addListener( IEventListenerPtr&& listener ) {
+++ updatePreferences(*listener);
+++ m_reporterLikes.insert(m_reporterLikes.begin() + m_insertedListeners, CATCH_MOVE(listener) );
+++ ++m_insertedListeners;
+++ }
+++
+++ void MultiReporter::addReporter( IEventListenerPtr&& reporter ) {
+++ updatePreferences(*reporter);
+++
+++ // We will need to output the captured stdout if there are reporters
+++ // that do not want it captured.
+++ // We do not consider listeners, because it is generally assumed that
+++ // listeners are output-transparent, even though they can ask for stdout
+++ // capture to do something with it.
+++ m_haveNoncapturingReporters |= !reporter->getPreferences().shouldRedirectStdOut;
+++
+++ // Reporters can always be placed to the back without breaking the
+++ // reporting order
+++ m_reporterLikes.push_back( CATCH_MOVE( reporter ) );
+++ }
+++
+++ void MultiReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
+++ for ( auto& reporterish : m_reporterLikes ) {
+++ reporterish->noMatchingTestCases( unmatchedSpec );
+++ }
+++ }
+++
+++ void MultiReporter::fatalErrorEncountered( StringRef error ) {
+++ for ( auto& reporterish : m_reporterLikes ) {
+++ reporterish->fatalErrorEncountered( error );
+++ }
+++ }
+++
+++ void MultiReporter::reportInvalidTestSpec( StringRef arg ) {
+++ for ( auto& reporterish : m_reporterLikes ) {
+++ reporterish->reportInvalidTestSpec( arg );
+++ }
+++ }
+++
+++ void MultiReporter::benchmarkPreparing( StringRef name ) {
+++ for (auto& reporterish : m_reporterLikes) {
+++ reporterish->benchmarkPreparing(name);
+++ }
+++ }
+++ void MultiReporter::benchmarkStarting( BenchmarkInfo const& benchmarkInfo ) {
+++ for ( auto& reporterish : m_reporterLikes ) {
+++ reporterish->benchmarkStarting( benchmarkInfo );
+++ }
+++ }
+++ void MultiReporter::benchmarkEnded( BenchmarkStats<> const& benchmarkStats ) {
+++ for ( auto& reporterish : m_reporterLikes ) {
+++ reporterish->benchmarkEnded( benchmarkStats );
+++ }
+++ }
+++
+++ void MultiReporter::benchmarkFailed( StringRef error ) {
+++ for (auto& reporterish : m_reporterLikes) {
+++ reporterish->benchmarkFailed(error);
+++ }
+++ }
+++
+++ void MultiReporter::testRunStarting( TestRunInfo const& testRunInfo ) {
+++ for ( auto& reporterish : m_reporterLikes ) {
+++ reporterish->testRunStarting( testRunInfo );
+++ }
+++ }
+++
+++ void MultiReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+++ for ( auto& reporterish : m_reporterLikes ) {
+++ reporterish->testCaseStarting( testInfo );
+++ }
+++ }
+++
+++ void
+++ MultiReporter::testCasePartialStarting( TestCaseInfo const& testInfo,
+++ uint64_t partNumber ) {
+++ for ( auto& reporterish : m_reporterLikes ) {
+++ reporterish->testCasePartialStarting( testInfo, partNumber );
+++ }
+++ }
+++
+++ void MultiReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+++ for ( auto& reporterish : m_reporterLikes ) {
+++ reporterish->sectionStarting( sectionInfo );
+++ }
+++ }
+++
+++ void MultiReporter::assertionStarting( AssertionInfo const& assertionInfo ) {
+++ for ( auto& reporterish : m_reporterLikes ) {
+++ reporterish->assertionStarting( assertionInfo );
+++ }
+++ }
+++
+++ void MultiReporter::assertionEnded( AssertionStats const& assertionStats ) {
+++ const bool reportByDefault =
+++ assertionStats.assertionResult.getResultType() != ResultWas::Ok ||
+++ m_config->includeSuccessfulResults();
+++
+++ for ( auto & reporterish : m_reporterLikes ) {
+++ if ( reportByDefault ||
+++ reporterish->getPreferences().shouldReportAllAssertions ) {
+++ reporterish->assertionEnded( assertionStats );
+++ }
+++ }
+++ }
+++
+++ void MultiReporter::sectionEnded( SectionStats const& sectionStats ) {
+++ for ( auto& reporterish : m_reporterLikes ) {
+++ reporterish->sectionEnded( sectionStats );
+++ }
+++ }
+++
+++ void MultiReporter::testCasePartialEnded( TestCaseStats const& testStats,
+++ uint64_t partNumber ) {
+++ if ( m_preferences.shouldRedirectStdOut &&
+++ m_haveNoncapturingReporters ) {
+++ if ( !testStats.stdOut.empty() ) {
+++ Catch::cout() << testStats.stdOut << std::flush;
+++ }
+++ if ( !testStats.stdErr.empty() ) {
+++ Catch::cerr() << testStats.stdErr << std::flush;
+++ }
+++ }
+++
+++ for ( auto& reporterish : m_reporterLikes ) {
+++ reporterish->testCasePartialEnded( testStats, partNumber );
+++ }
+++ }
+++
+++ void MultiReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+++ for ( auto& reporterish : m_reporterLikes ) {
+++ reporterish->testCaseEnded( testCaseStats );
+++ }
+++ }
+++
+++ void MultiReporter::testRunEnded( TestRunStats const& testRunStats ) {
+++ for ( auto& reporterish : m_reporterLikes ) {
+++ reporterish->testRunEnded( testRunStats );
+++ }
+++ }
+++
+++
+++ void MultiReporter::skipTest( TestCaseInfo const& testInfo ) {
+++ for ( auto& reporterish : m_reporterLikes ) {
+++ reporterish->skipTest( testInfo );
+++ }
+++ }
+++
+++ void MultiReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
+++ for (auto& reporterish : m_reporterLikes) {
+++ reporterish->listReporters(descriptions);
+++ }
+++ }
+++
+++ void MultiReporter::listListeners(
+++ std::vector<ListenerDescription> const& descriptions ) {
+++ for ( auto& reporterish : m_reporterLikes ) {
+++ reporterish->listListeners( descriptions );
+++ }
+++ }
+++
+++ void MultiReporter::listTests(std::vector<TestCaseHandle> const& tests) {
+++ for (auto& reporterish : m_reporterLikes) {
+++ reporterish->listTests(tests);
+++ }
+++ }
+++
+++ void MultiReporter::listTags(std::vector<TagInfo> const& tags) {
+++ for (auto& reporterish : m_reporterLikes) {
+++ reporterish->listTags(tags);
+++ }
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++
+++namespace Catch {
+++ namespace Detail {
+++
+++ void registerReporterImpl( std::string const& name,
+++ IReporterFactoryPtr reporterPtr ) {
+++ CATCH_TRY {
+++ getMutableRegistryHub().registerReporter(
+++ name, CATCH_MOVE( reporterPtr ) );
+++ }
+++ CATCH_CATCH_ALL {
+++ // Do not throw when constructing global objects, instead
+++ // register the exception to be processed later
+++ getMutableRegistryHub().registerStartupException();
+++ }
+++ }
+++
+++ void registerListenerImpl( Detail::unique_ptr<EventListenerFactory> listenerFactory ) {
+++ getMutableRegistryHub().registerListener( CATCH_MOVE(listenerFactory) );
+++ }
+++
+++
+++ } // namespace Detail
+++} // namespace Catch
+++
+++
+++
+++
+++#include <map>
+++
+++namespace Catch {
+++
+++ namespace {
+++ std::string createMetadataString(IConfig const& config) {
+++ ReusableStringStream sstr;
+++ if ( config.testSpec().hasFilters() ) {
+++ sstr << "filters='"
+++ << config.testSpec()
+++ << "' ";
+++ }
+++ sstr << "rng-seed=" << config.rngSeed();
+++ return sstr.str();
+++ }
+++ }
+++
+++ void SonarQubeReporter::testRunStarting(TestRunInfo const& testRunInfo) {
+++ CumulativeReporterBase::testRunStarting(testRunInfo);
+++
+++ xml.writeComment( createMetadataString( *m_config ) );
+++ xml.startElement("testExecutions");
+++ xml.writeAttribute("version"_sr, '1');
+++ }
+++
+++ void SonarQubeReporter::writeRun( TestRunNode const& runNode ) {
+++ std::map<StringRef, std::vector<TestCaseNode const*>> testsPerFile;
+++
+++ for ( auto const& child : runNode.children ) {
+++ testsPerFile[child->value.testInfo->lineInfo.file].push_back(
+++ child.get() );
+++ }
+++
+++ for ( auto const& kv : testsPerFile ) {
+++ writeTestFile( kv.first, kv.second );
+++ }
+++ }
+++
+++ void SonarQubeReporter::writeTestFile(StringRef filename, std::vector<TestCaseNode const*> const& testCaseNodes) {
+++ XmlWriter::ScopedElement e = xml.scopedElement("file");
+++ xml.writeAttribute("path"_sr, filename);
+++
+++ for (auto const& child : testCaseNodes)
+++ writeTestCase(*child);
+++ }
+++
+++ void SonarQubeReporter::writeTestCase(TestCaseNode const& testCaseNode) {
+++ // All test cases have exactly one section - which represents the
+++ // test case itself. That section may have 0-n nested sections
+++ assert(testCaseNode.children.size() == 1);
+++ SectionNode const& rootSection = *testCaseNode.children.front();
+++ writeSection("", rootSection, testCaseNode.value.testInfo->okToFail());
+++ }
+++
+++ void SonarQubeReporter::writeSection(std::string const& rootName, SectionNode const& sectionNode, bool okToFail) {
+++ std::string name = trim(sectionNode.stats.sectionInfo.name);
+++ if (!rootName.empty())
+++ name = rootName + '/' + name;
+++
+++ if ( sectionNode.hasAnyAssertions()
+++ || !sectionNode.stdOut.empty()
+++ || !sectionNode.stdErr.empty() ) {
+++ XmlWriter::ScopedElement e = xml.scopedElement("testCase");
+++ xml.writeAttribute("name"_sr, name);
+++ xml.writeAttribute("duration"_sr, static_cast<long>(sectionNode.stats.durationInSeconds * 1000));
+++
+++ writeAssertions(sectionNode, okToFail);
+++ }
+++
+++ for (auto const& childNode : sectionNode.childSections)
+++ writeSection(name, *childNode, okToFail);
+++ }
+++
+++ void SonarQubeReporter::writeAssertions(SectionNode const& sectionNode, bool okToFail) {
+++ for (auto const& assertionOrBenchmark : sectionNode.assertionsAndBenchmarks) {
+++ if (assertionOrBenchmark.isAssertion()) {
+++ writeAssertion(assertionOrBenchmark.asAssertion(), okToFail);
+++ }
+++ }
+++ }
+++
+++ void SonarQubeReporter::writeAssertion(AssertionStats const& stats, bool okToFail) {
+++ AssertionResult const& result = stats.assertionResult;
+++ if ( !result.isOk() ||
+++ result.getResultType() == ResultWas::ExplicitSkip ) {
+++ std::string elementName;
+++ if (okToFail) {
+++ elementName = "skipped";
+++ } else {
+++ switch (result.getResultType()) {
+++ case ResultWas::ThrewException:
+++ case ResultWas::FatalErrorCondition:
+++ elementName = "error";
+++ break;
+++ case ResultWas::ExplicitFailure:
+++ case ResultWas::ExpressionFailed:
+++ case ResultWas::DidntThrowException:
+++ elementName = "failure";
+++ break;
+++ case ResultWas::ExplicitSkip:
+++ elementName = "skipped";
+++ break;
+++ // We should never see these here:
+++ case ResultWas::Info:
+++ case ResultWas::Warning:
+++ case ResultWas::Ok:
+++ case ResultWas::Unknown:
+++ case ResultWas::FailureBit:
+++ case ResultWas::Exception:
+++ elementName = "internalError";
+++ break;
+++ }
+++ }
+++
+++ XmlWriter::ScopedElement e = xml.scopedElement(elementName);
+++
+++ ReusableStringStream messageRss;
+++ messageRss << result.getTestMacroName() << '(' << result.getExpression() << ')';
+++ xml.writeAttribute("message"_sr, messageRss.str());
+++
+++ ReusableStringStream textRss;
+++ if ( result.getResultType() == ResultWas::ExplicitSkip ) {
+++ textRss << "SKIPPED\n";
+++ } else {
+++ textRss << "FAILED:\n";
+++ if (result.hasExpression()) {
+++ textRss << '\t' << result.getExpressionInMacro() << '\n';
+++ }
+++ if (result.hasExpandedExpression()) {
+++ textRss << "with expansion:\n\t" << result.getExpandedExpression() << '\n';
+++ }
+++ }
+++
+++ if (result.hasMessage())
+++ textRss << result.getMessage() << '\n';
+++
+++ for (auto const& msg : stats.infoMessages)
+++ if (msg.type == ResultWas::Info)
+++ textRss << msg.message << '\n';
+++
+++ textRss << "at " << result.getSourceInfo();
+++ xml.writeText(textRss.str(), XmlFormatting::Newline);
+++ }
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++namespace Catch {
+++
+++ StreamingReporterBase::~StreamingReporterBase() = default;
+++
+++ void
+++ StreamingReporterBase::testRunStarting( TestRunInfo const& _testRunInfo ) {
+++ currentTestRunInfo = _testRunInfo;
+++ }
+++
+++ void StreamingReporterBase::testRunEnded( TestRunStats const& ) {
+++ currentTestCaseInfo = nullptr;
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++#include <algorithm>
+++#include <ostream>
+++
+++namespace Catch {
+++
+++ namespace {
+++ // Yes, this has to be outside the class and namespaced by naming.
+++ // Making older compiler happy is hard.
+++ static constexpr StringRef tapFailedString = "not ok"_sr;
+++ static constexpr StringRef tapPassedString = "ok"_sr;
+++ static constexpr Colour::Code tapDimColour = Colour::FileName;
+++
+++ class TapAssertionPrinter {
+++ public:
+++ TapAssertionPrinter& operator= (TapAssertionPrinter const&) = delete;
+++ TapAssertionPrinter(TapAssertionPrinter const&) = delete;
+++ TapAssertionPrinter(std::ostream& _stream, AssertionStats const& _stats, std::size_t _counter, ColourImpl* colour_)
+++ : stream(_stream)
+++ , result(_stats.assertionResult)
+++ , messages(_stats.infoMessages)
+++ , itMessage(_stats.infoMessages.begin())
+++ , printInfoMessages(true)
+++ , counter(_counter)
+++ , colourImpl( colour_ ) {}
+++
+++ void print() {
+++ itMessage = messages.begin();
+++
+++ switch (result.getResultType()) {
+++ case ResultWas::Ok:
+++ printResultType(tapPassedString);
+++ printOriginalExpression();
+++ printReconstructedExpression();
+++ if (!result.hasExpression())
+++ printRemainingMessages(Colour::None);
+++ else
+++ printRemainingMessages();
+++ break;
+++ case ResultWas::ExpressionFailed:
+++ if (result.isOk()) {
+++ printResultType(tapPassedString);
+++ } else {
+++ printResultType(tapFailedString);
+++ }
+++ printOriginalExpression();
+++ printReconstructedExpression();
+++ if (result.isOk()) {
+++ printIssue(" # TODO");
+++ }
+++ printRemainingMessages();
+++ break;
+++ case ResultWas::ThrewException:
+++ printResultType(tapFailedString);
+++ printIssue("unexpected exception with message:"_sr);
+++ printMessage();
+++ printExpressionWas();
+++ printRemainingMessages();
+++ break;
+++ case ResultWas::FatalErrorCondition:
+++ printResultType(tapFailedString);
+++ printIssue("fatal error condition with message:"_sr);
+++ printMessage();
+++ printExpressionWas();
+++ printRemainingMessages();
+++ break;
+++ case ResultWas::DidntThrowException:
+++ printResultType(tapFailedString);
+++ printIssue("expected exception, got none"_sr);
+++ printExpressionWas();
+++ printRemainingMessages();
+++ break;
+++ case ResultWas::Info:
+++ printResultType("info"_sr);
+++ printMessage();
+++ printRemainingMessages();
+++ break;
+++ case ResultWas::Warning:
+++ printResultType("warning"_sr);
+++ printMessage();
+++ printRemainingMessages();
+++ break;
+++ case ResultWas::ExplicitFailure:
+++ printResultType(tapFailedString);
+++ printIssue("explicitly"_sr);
+++ printRemainingMessages(Colour::None);
+++ break;
+++ case ResultWas::ExplicitSkip:
+++ printResultType(tapPassedString);
+++ printIssue(" # SKIP"_sr);
+++ printMessage();
+++ printRemainingMessages();
+++ break;
+++ // These cases are here to prevent compiler warnings
+++ case ResultWas::Unknown:
+++ case ResultWas::FailureBit:
+++ case ResultWas::Exception:
+++ printResultType("** internal error **"_sr);
+++ break;
+++ }
+++ }
+++
+++ private:
+++ void printResultType(StringRef passOrFail) const {
+++ if (!passOrFail.empty()) {
+++ stream << passOrFail << ' ' << counter << " -";
+++ }
+++ }
+++
+++ void printIssue(StringRef issue) const {
+++ stream << ' ' << issue;
+++ }
+++
+++ void printExpressionWas() {
+++ if (result.hasExpression()) {
+++ stream << ';';
+++ stream << colourImpl->guardColour( tapDimColour )
+++ << " expression was:";
+++ printOriginalExpression();
+++ }
+++ }
+++
+++ void printOriginalExpression() const {
+++ if (result.hasExpression()) {
+++ stream << ' ' << result.getExpression();
+++ }
+++ }
+++
+++ void printReconstructedExpression() const {
+++ if (result.hasExpandedExpression()) {
+++ stream << colourImpl->guardColour( tapDimColour ) << " for: ";
+++
+++ std::string expr = result.getExpandedExpression();
+++ std::replace(expr.begin(), expr.end(), '\n', ' ');
+++ stream << expr;
+++ }
+++ }
+++
+++ void printMessage() {
+++ if (itMessage != messages.end()) {
+++ stream << " '" << itMessage->message << '\'';
+++ ++itMessage;
+++ }
+++ }
+++
+++ void printRemainingMessages(Colour::Code colour = tapDimColour) {
+++ if (itMessage == messages.end()) {
+++ return;
+++ }
+++
+++ // using messages.end() directly (or auto) yields compilation error:
+++ std::vector<MessageInfo>::const_iterator itEnd = messages.end();
+++ const std::size_t N = static_cast<std::size_t>(itEnd - itMessage);
+++
+++ stream << colourImpl->guardColour( colour ) << " with "
+++ << pluralise( N, "message"_sr ) << ':';
+++
+++ for (; itMessage != itEnd; ) {
+++ // If this assertion is a warning ignore any INFO messages
+++ if (printInfoMessages || itMessage->type != ResultWas::Info) {
+++ stream << " '" << itMessage->message << '\'';
+++ if (++itMessage != itEnd) {
+++ stream << colourImpl->guardColour(tapDimColour) << " and";
+++ }
+++ }
+++ }
+++ }
+++
+++ private:
+++ std::ostream& stream;
+++ AssertionResult const& result;
+++ std::vector<MessageInfo> const& messages;
+++ std::vector<MessageInfo>::const_iterator itMessage;
+++ bool printInfoMessages;
+++ std::size_t counter;
+++ ColourImpl* colourImpl;
+++ };
+++
+++ } // End anonymous namespace
+++
+++ void TAPReporter::testRunStarting( TestRunInfo const& ) {
+++ if ( m_config->testSpec().hasFilters() ) {
+++ m_stream << "# filters: " << m_config->testSpec() << '\n';
+++ }
+++ m_stream << "# rng-seed: " << m_config->rngSeed() << '\n';
+++ }
+++
+++ void TAPReporter::noMatchingTestCases( StringRef unmatchedSpec ) {
+++ m_stream << "# No test cases matched '" << unmatchedSpec << "'\n";
+++ }
+++
+++ void TAPReporter::assertionEnded(AssertionStats const& _assertionStats) {
+++ ++counter;
+++
+++ m_stream << "# " << currentTestCaseInfo->name << '\n';
+++ TapAssertionPrinter printer(m_stream, _assertionStats, counter, m_colour.get());
+++ printer.print();
+++
+++ m_stream << '\n' << std::flush;
+++ }
+++
+++ void TAPReporter::testRunEnded(TestRunStats const& _testRunStats) {
+++ m_stream << "1.." << _testRunStats.totals.assertions.total();
+++ if (_testRunStats.totals.testCases.total() == 0) {
+++ m_stream << " # Skipped: No tests ran.";
+++ }
+++ m_stream << "\n\n" << std::flush;
+++ StreamingReporterBase::testRunEnded(_testRunStats);
+++ }
+++
+++
+++
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++#include <cassert>
+++#include <ostream>
+++
+++namespace Catch {
+++
+++ namespace {
+++ // if string has a : in first line will set indent to follow it on
+++ // subsequent lines
+++ void printHeaderString(std::ostream& os, std::string const& _string, std::size_t indent = 0) {
+++ std::size_t i = _string.find(": ");
+++ if (i != std::string::npos)
+++ i += 2;
+++ else
+++ i = 0;
+++ os << TextFlow::Column(_string)
+++ .indent(indent + i)
+++ .initialIndent(indent) << '\n';
+++ }
+++
+++ std::string escape(StringRef str) {
+++ std::string escaped = static_cast<std::string>(str);
+++ replaceInPlace(escaped, "|", "||");
+++ replaceInPlace(escaped, "'", "|'");
+++ replaceInPlace(escaped, "\n", "|n");
+++ replaceInPlace(escaped, "\r", "|r");
+++ replaceInPlace(escaped, "[", "|[");
+++ replaceInPlace(escaped, "]", "|]");
+++ return escaped;
+++ }
+++ } // end anonymous namespace
+++
+++
+++ TeamCityReporter::~TeamCityReporter() = default;
+++
+++ void TeamCityReporter::testRunStarting( TestRunInfo const& runInfo ) {
+++ m_stream << "##teamcity[testSuiteStarted name='" << escape( runInfo.name )
+++ << "']\n";
+++ }
+++
+++ void TeamCityReporter::testRunEnded( TestRunStats const& runStats ) {
+++ m_stream << "##teamcity[testSuiteFinished name='"
+++ << escape( runStats.runInfo.name ) << "']\n";
+++ }
+++
+++ void TeamCityReporter::assertionEnded(AssertionStats const& assertionStats) {
+++ AssertionResult const& result = assertionStats.assertionResult;
+++ if ( !result.isOk() ||
+++ result.getResultType() == ResultWas::ExplicitSkip ) {
+++
+++ ReusableStringStream msg;
+++ if (!m_headerPrintedForThisSection)
+++ printSectionHeader(msg.get());
+++ m_headerPrintedForThisSection = true;
+++
+++ msg << result.getSourceInfo() << '\n';
+++
+++ switch (result.getResultType()) {
+++ case ResultWas::ExpressionFailed:
+++ msg << "expression failed";
+++ break;
+++ case ResultWas::ThrewException:
+++ msg << "unexpected exception";
+++ break;
+++ case ResultWas::FatalErrorCondition:
+++ msg << "fatal error condition";
+++ break;
+++ case ResultWas::DidntThrowException:
+++ msg << "no exception was thrown where one was expected";
+++ break;
+++ case ResultWas::ExplicitFailure:
+++ msg << "explicit failure";
+++ break;
+++ case ResultWas::ExplicitSkip:
+++ msg << "explicit skip";
+++ break;
+++
+++ // We shouldn't get here because of the isOk() test
+++ case ResultWas::Ok:
+++ case ResultWas::Info:
+++ case ResultWas::Warning:
+++ CATCH_ERROR("Internal error in TeamCity reporter");
+++ // These cases are here to prevent compiler warnings
+++ case ResultWas::Unknown:
+++ case ResultWas::FailureBit:
+++ case ResultWas::Exception:
+++ CATCH_ERROR("Not implemented");
+++ }
+++ if (assertionStats.infoMessages.size() == 1)
+++ msg << " with message:";
+++ if (assertionStats.infoMessages.size() > 1)
+++ msg << " with messages:";
+++ for (auto const& messageInfo : assertionStats.infoMessages)
+++ msg << "\n \"" << messageInfo.message << '"';
+++
+++
+++ if (result.hasExpression()) {
+++ msg <<
+++ "\n " << result.getExpressionInMacro() << "\n"
+++ "with expansion:\n"
+++ " " << result.getExpandedExpression() << '\n';
+++ }
+++
+++ if ( result.getResultType() == ResultWas::ExplicitSkip ) {
+++ m_stream << "##teamcity[testIgnored";
+++ } else if ( currentTestCaseInfo->okToFail() ) {
+++ msg << "- failure ignore as test marked as 'ok to fail'\n";
+++ m_stream << "##teamcity[testIgnored";
+++ } else {
+++ m_stream << "##teamcity[testFailed";
+++ }
+++ m_stream << " name='" << escape( currentTestCaseInfo->name ) << '\''
+++ << " message='" << escape( msg.str() ) << '\'' << "]\n";
+++ }
+++ m_stream.flush();
+++ }
+++
+++ void TeamCityReporter::testCaseStarting(TestCaseInfo const& testInfo) {
+++ m_testTimer.start();
+++ StreamingReporterBase::testCaseStarting(testInfo);
+++ m_stream << "##teamcity[testStarted name='"
+++ << escape(testInfo.name) << "']\n";
+++ m_stream.flush();
+++ }
+++
+++ void TeamCityReporter::testCaseEnded(TestCaseStats const& testCaseStats) {
+++ StreamingReporterBase::testCaseEnded(testCaseStats);
+++ auto const& testCaseInfo = *testCaseStats.testInfo;
+++ if (!testCaseStats.stdOut.empty())
+++ m_stream << "##teamcity[testStdOut name='"
+++ << escape(testCaseInfo.name)
+++ << "' out='" << escape(testCaseStats.stdOut) << "']\n";
+++ if (!testCaseStats.stdErr.empty())
+++ m_stream << "##teamcity[testStdErr name='"
+++ << escape(testCaseInfo.name)
+++ << "' out='" << escape(testCaseStats.stdErr) << "']\n";
+++ m_stream << "##teamcity[testFinished name='"
+++ << escape(testCaseInfo.name) << "' duration='"
+++ << m_testTimer.getElapsedMilliseconds() << "']\n";
+++ m_stream.flush();
+++ }
+++
+++ void TeamCityReporter::printSectionHeader(std::ostream& os) {
+++ assert(!m_sectionStack.empty());
+++
+++ if (m_sectionStack.size() > 1) {
+++ os << lineOfChars('-') << '\n';
+++
+++ std::vector<SectionInfo>::const_iterator
+++ it = m_sectionStack.begin() + 1, // Skip first section (test case)
+++ itEnd = m_sectionStack.end();
+++ for (; it != itEnd; ++it)
+++ printHeaderString(os, it->name);
+++ os << lineOfChars('-') << '\n';
+++ }
+++
+++ SourceLineInfo lineInfo = m_sectionStack.front().lineInfo;
+++
+++ os << lineInfo << '\n';
+++ os << lineOfChars('.') << "\n\n";
+++ }
+++
+++} // end namespace Catch
+++
+++
+++
+++
+++#if defined(_MSC_VER)
+++#pragma warning(push)
+++#pragma warning(disable:4061) // Not all labels are EXPLICITLY handled in switch
+++ // Note that 4062 (not all labels are handled
+++ // and default is missing) is enabled
+++#endif
+++
+++namespace Catch {
+++ XmlReporter::XmlReporter( ReporterConfig&& _config )
+++ : StreamingReporterBase( CATCH_MOVE(_config) ),
+++ m_xml(m_stream)
+++ {
+++ m_preferences.shouldRedirectStdOut = true;
+++ m_preferences.shouldReportAllAssertions = true;
+++ }
+++
+++ XmlReporter::~XmlReporter() = default;
+++
+++ std::string XmlReporter::getDescription() {
+++ return "Reports test results as an XML document";
+++ }
+++
+++ std::string XmlReporter::getStylesheetRef() const {
+++ return std::string();
+++ }
+++
+++ void XmlReporter::writeSourceInfo( SourceLineInfo const& sourceInfo ) {
+++ m_xml
+++ .writeAttribute( "filename"_sr, sourceInfo.file )
+++ .writeAttribute( "line"_sr, sourceInfo.line );
+++ }
+++
+++ void XmlReporter::testRunStarting( TestRunInfo const& testInfo ) {
+++ StreamingReporterBase::testRunStarting( testInfo );
+++ std::string stylesheetRef = getStylesheetRef();
+++ if( !stylesheetRef.empty() )
+++ m_xml.writeStylesheetRef( stylesheetRef );
+++ m_xml.startElement("Catch2TestRun")
+++ .writeAttribute("name"_sr, m_config->name())
+++ .writeAttribute("rng-seed"_sr, m_config->rngSeed())
+++ .writeAttribute("xml-format-version"_sr, 3)
+++ .writeAttribute("catch2-version"_sr, libraryVersion());
+++ if ( m_config->testSpec().hasFilters() ) {
+++ m_xml.writeAttribute( "filters"_sr, m_config->testSpec() );
+++ }
+++ }
+++
+++ void XmlReporter::testCaseStarting( TestCaseInfo const& testInfo ) {
+++ StreamingReporterBase::testCaseStarting(testInfo);
+++ m_xml.startElement( "TestCase" )
+++ .writeAttribute( "name"_sr, trim( StringRef(testInfo.name) ) )
+++ .writeAttribute( "tags"_sr, testInfo.tagsAsString() );
+++
+++ writeSourceInfo( testInfo.lineInfo );
+++
+++ if ( m_config->showDurations() == ShowDurations::Always )
+++ m_testCaseTimer.start();
+++ m_xml.ensureTagClosed();
+++ }
+++
+++ void XmlReporter::sectionStarting( SectionInfo const& sectionInfo ) {
+++ StreamingReporterBase::sectionStarting( sectionInfo );
+++ if( m_sectionDepth++ > 0 ) {
+++ m_xml.startElement( "Section" )
+++ .writeAttribute( "name"_sr, trim( StringRef(sectionInfo.name) ) );
+++ writeSourceInfo( sectionInfo.lineInfo );
+++ m_xml.ensureTagClosed();
+++ }
+++ }
+++
+++ void XmlReporter::assertionStarting( AssertionInfo const& ) { }
+++
+++ void XmlReporter::assertionEnded( AssertionStats const& assertionStats ) {
+++
+++ AssertionResult const& result = assertionStats.assertionResult;
+++
+++ bool includeResults = m_config->includeSuccessfulResults() || !result.isOk();
+++
+++ if( includeResults || result.getResultType() == ResultWas::Warning ) {
+++ // Print any info messages in <Info> tags.
+++ for( auto const& msg : assertionStats.infoMessages ) {
+++ if( msg.type == ResultWas::Info && includeResults ) {
+++ auto t = m_xml.scopedElement( "Info" );
+++ writeSourceInfo( msg.lineInfo );
+++ t.writeText( msg.message );
+++ } else if ( msg.type == ResultWas::Warning ) {
+++ auto t = m_xml.scopedElement( "Warning" );
+++ writeSourceInfo( msg.lineInfo );
+++ t.writeText( msg.message );
+++ }
+++ }
+++ }
+++
+++ // Drop out if result was successful but we're not printing them.
+++ if ( !includeResults && result.getResultType() != ResultWas::Warning &&
+++ result.getResultType() != ResultWas::ExplicitSkip ) {
+++ return;
+++ }
+++
+++ // Print the expression if there is one.
+++ if( result.hasExpression() ) {
+++ m_xml.startElement( "Expression" )
+++ .writeAttribute( "success"_sr, result.succeeded() )
+++ .writeAttribute( "type"_sr, result.getTestMacroName() );
+++
+++ writeSourceInfo( result.getSourceInfo() );
+++
+++ m_xml.scopedElement( "Original" )
+++ .writeText( result.getExpression() );
+++ m_xml.scopedElement( "Expanded" )
+++ .writeText( result.getExpandedExpression() );
+++ }
+++
+++ // And... Print a result applicable to each result type.
+++ switch( result.getResultType() ) {
+++ case ResultWas::ThrewException:
+++ m_xml.startElement( "Exception" );
+++ writeSourceInfo( result.getSourceInfo() );
+++ m_xml.writeText( result.getMessage() );
+++ m_xml.endElement();
+++ break;
+++ case ResultWas::FatalErrorCondition:
+++ m_xml.startElement( "FatalErrorCondition" );
+++ writeSourceInfo( result.getSourceInfo() );
+++ m_xml.writeText( result.getMessage() );
+++ m_xml.endElement();
+++ break;
+++ case ResultWas::Info:
+++ m_xml.scopedElement( "Info" )
+++ .writeText( result.getMessage() );
+++ break;
+++ case ResultWas::Warning:
+++ // Warning will already have been written
+++ break;
+++ case ResultWas::ExplicitFailure:
+++ m_xml.startElement( "Failure" );
+++ writeSourceInfo( result.getSourceInfo() );
+++ m_xml.writeText( result.getMessage() );
+++ m_xml.endElement();
+++ break;
+++ case ResultWas::ExplicitSkip:
+++ m_xml.startElement( "Skip" );
+++ writeSourceInfo( result.getSourceInfo() );
+++ m_xml.writeText( result.getMessage() );
+++ m_xml.endElement();
+++ break;
+++ default:
+++ break;
+++ }
+++
+++ if( result.hasExpression() )
+++ m_xml.endElement();
+++ }
+++
+++ void XmlReporter::sectionEnded( SectionStats const& sectionStats ) {
+++ StreamingReporterBase::sectionEnded( sectionStats );
+++ if ( --m_sectionDepth > 0 ) {
+++ {
+++ XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResults" );
+++ e.writeAttribute( "successes"_sr, sectionStats.assertions.passed );
+++ e.writeAttribute( "failures"_sr, sectionStats.assertions.failed );
+++ e.writeAttribute( "expectedFailures"_sr, sectionStats.assertions.failedButOk );
+++ e.writeAttribute( "skipped"_sr, sectionStats.assertions.skipped > 0 );
+++
+++ if ( m_config->showDurations() == ShowDurations::Always )
+++ e.writeAttribute( "durationInSeconds"_sr, sectionStats.durationInSeconds );
+++ }
+++ // Ends assertion tag
+++ m_xml.endElement();
+++ }
+++ }
+++
+++ void XmlReporter::testCaseEnded( TestCaseStats const& testCaseStats ) {
+++ StreamingReporterBase::testCaseEnded( testCaseStats );
+++ XmlWriter::ScopedElement e = m_xml.scopedElement( "OverallResult" );
+++ e.writeAttribute( "success"_sr, testCaseStats.totals.assertions.allOk() );
+++ e.writeAttribute( "skips"_sr, testCaseStats.totals.assertions.skipped );
+++
+++ if ( m_config->showDurations() == ShowDurations::Always )
+++ e.writeAttribute( "durationInSeconds"_sr, m_testCaseTimer.getElapsedSeconds() );
+++ if( !testCaseStats.stdOut.empty() )
+++ m_xml.scopedElement( "StdOut" ).writeText( trim( StringRef(testCaseStats.stdOut) ), XmlFormatting::Newline );
+++ if( !testCaseStats.stdErr.empty() )
+++ m_xml.scopedElement( "StdErr" ).writeText( trim( StringRef(testCaseStats.stdErr) ), XmlFormatting::Newline );
+++
+++ m_xml.endElement();
+++ }
+++
+++ void XmlReporter::testRunEnded( TestRunStats const& testRunStats ) {
+++ StreamingReporterBase::testRunEnded( testRunStats );
+++ m_xml.scopedElement( "OverallResults" )
+++ .writeAttribute( "successes"_sr, testRunStats.totals.assertions.passed )
+++ .writeAttribute( "failures"_sr, testRunStats.totals.assertions.failed )
+++ .writeAttribute( "expectedFailures"_sr, testRunStats.totals.assertions.failedButOk )
+++ .writeAttribute( "skips"_sr, testRunStats.totals.assertions.skipped );
+++ m_xml.scopedElement( "OverallResultsCases")
+++ .writeAttribute( "successes"_sr, testRunStats.totals.testCases.passed )
+++ .writeAttribute( "failures"_sr, testRunStats.totals.testCases.failed )
+++ .writeAttribute( "expectedFailures"_sr, testRunStats.totals.testCases.failedButOk )
+++ .writeAttribute( "skips"_sr, testRunStats.totals.testCases.skipped );
+++ m_xml.endElement();
+++ }
+++
+++ void XmlReporter::benchmarkPreparing( StringRef name ) {
+++ m_xml.startElement("BenchmarkResults")
+++ .writeAttribute("name"_sr, name);
+++ }
+++
+++ void XmlReporter::benchmarkStarting(BenchmarkInfo const &info) {
+++ m_xml.writeAttribute("samples"_sr, info.samples)
+++ .writeAttribute("resamples"_sr, info.resamples)
+++ .writeAttribute("iterations"_sr, info.iterations)
+++ .writeAttribute("clockResolution"_sr, info.clockResolution)
+++ .writeAttribute("estimatedDuration"_sr, info.estimatedDuration)
+++ .writeComment("All values in nano seconds"_sr);
+++ }
+++
+++ void XmlReporter::benchmarkEnded(BenchmarkStats<> const& benchmarkStats) {
+++ m_xml.scopedElement("mean")
+++ .writeAttribute("value"_sr, benchmarkStats.mean.point.count())
+++ .writeAttribute("lowerBound"_sr, benchmarkStats.mean.lower_bound.count())
+++ .writeAttribute("upperBound"_sr, benchmarkStats.mean.upper_bound.count())
+++ .writeAttribute("ci"_sr, benchmarkStats.mean.confidence_interval);
+++ m_xml.scopedElement("standardDeviation")
+++ .writeAttribute("value"_sr, benchmarkStats.standardDeviation.point.count())
+++ .writeAttribute("lowerBound"_sr, benchmarkStats.standardDeviation.lower_bound.count())
+++ .writeAttribute("upperBound"_sr, benchmarkStats.standardDeviation.upper_bound.count())
+++ .writeAttribute("ci"_sr, benchmarkStats.standardDeviation.confidence_interval);
+++ m_xml.scopedElement("outliers")
+++ .writeAttribute("variance"_sr, benchmarkStats.outlierVariance)
+++ .writeAttribute("lowMild"_sr, benchmarkStats.outliers.low_mild)
+++ .writeAttribute("lowSevere"_sr, benchmarkStats.outliers.low_severe)
+++ .writeAttribute("highMild"_sr, benchmarkStats.outliers.high_mild)
+++ .writeAttribute("highSevere"_sr, benchmarkStats.outliers.high_severe);
+++ m_xml.endElement();
+++ }
+++
+++ void XmlReporter::benchmarkFailed(StringRef error) {
+++ m_xml.scopedElement("failed").
+++ writeAttribute("message"_sr, error);
+++ m_xml.endElement();
+++ }
+++
+++ void XmlReporter::listReporters(std::vector<ReporterDescription> const& descriptions) {
+++ auto outerTag = m_xml.scopedElement("AvailableReporters");
+++ for (auto const& reporter : descriptions) {
+++ auto inner = m_xml.scopedElement("Reporter");
+++ m_xml.startElement("Name", XmlFormatting::Indent)
+++ .writeText(reporter.name, XmlFormatting::None)
+++ .endElement(XmlFormatting::Newline);
+++ m_xml.startElement("Description", XmlFormatting::Indent)
+++ .writeText(reporter.description, XmlFormatting::None)
+++ .endElement(XmlFormatting::Newline);
+++ }
+++ }
+++
+++ void XmlReporter::listListeners(std::vector<ListenerDescription> const& descriptions) {
+++ auto outerTag = m_xml.scopedElement( "RegisteredListeners" );
+++ for ( auto const& listener : descriptions ) {
+++ auto inner = m_xml.scopedElement( "Listener" );
+++ m_xml.startElement( "Name", XmlFormatting::Indent )
+++ .writeText( listener.name, XmlFormatting::None )
+++ .endElement( XmlFormatting::Newline );
+++ m_xml.startElement( "Description", XmlFormatting::Indent )
+++ .writeText( listener.description, XmlFormatting::None )
+++ .endElement( XmlFormatting::Newline );
+++ }
+++ }
+++
+++ void XmlReporter::listTests(std::vector<TestCaseHandle> const& tests) {
+++ auto outerTag = m_xml.scopedElement("MatchingTests");
+++ for (auto const& test : tests) {
+++ auto innerTag = m_xml.scopedElement("TestCase");
+++ auto const& testInfo = test.getTestCaseInfo();
+++ m_xml.startElement("Name", XmlFormatting::Indent)
+++ .writeText(testInfo.name, XmlFormatting::None)
+++ .endElement(XmlFormatting::Newline);
+++ m_xml.startElement("ClassName", XmlFormatting::Indent)
+++ .writeText(testInfo.className, XmlFormatting::None)
+++ .endElement(XmlFormatting::Newline);
+++ m_xml.startElement("Tags", XmlFormatting::Indent)
+++ .writeText(testInfo.tagsAsString(), XmlFormatting::None)
+++ .endElement(XmlFormatting::Newline);
+++
+++ auto sourceTag = m_xml.scopedElement("SourceInfo");
+++ m_xml.startElement("File", XmlFormatting::Indent)
+++ .writeText(testInfo.lineInfo.file, XmlFormatting::None)
+++ .endElement(XmlFormatting::Newline);
+++ m_xml.startElement("Line", XmlFormatting::Indent)
+++ .writeText(std::to_string(testInfo.lineInfo.line), XmlFormatting::None)
+++ .endElement(XmlFormatting::Newline);
+++ }
+++ }
+++
+++ void XmlReporter::listTags(std::vector<TagInfo> const& tags) {
+++ auto outerTag = m_xml.scopedElement("TagsFromMatchingTests");
+++ for (auto const& tag : tags) {
+++ auto innerTag = m_xml.scopedElement("Tag");
+++ m_xml.startElement("Count", XmlFormatting::Indent)
+++ .writeText(std::to_string(tag.count), XmlFormatting::None)
+++ .endElement(XmlFormatting::Newline);
+++ auto aliasTag = m_xml.scopedElement("Aliases");
+++ for (auto const& alias : tag.spellings) {
+++ m_xml.startElement("Alias", XmlFormatting::Indent)
+++ .writeText(alias, XmlFormatting::None)
+++ .endElement(XmlFormatting::Newline);
+++ }
+++ }
+++ }
+++
+++} // end namespace Catch
+++
+++#if defined(_MSC_VER)
+++#pragma warning(pop)
+++#endif
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/multi_accept.cpp
++@@ -0,0 +1,129 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include <functional>
+++
+++#include "catch.hpp"
+++
+++#ifdef __GNUC__
+++// for CATCH's CHECK macro
+++#pragma GCC diagnostic ignored "-Wparentheses"
+++#endif
+++
+++using namespace sim::asio;
+++using namespace sim::chrono;
+++using sim::simulation;
+++using sim::default_config;
+++using namespace std::placeholders;
+++
+++namespace {
+++
+++int num_incoming = 0;
+++int num_connected = 0;
+++
+++int counter = 0;
+++
+++void incoming_connection(boost::system::error_code const& ec
+++ , ip::tcp::socket& sock, ip::tcp::acceptor& listener)
+++{
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++ if (ec)
+++ {
+++ std::printf("[%4d] error while accepting connection: %s\n"
+++ , millis, ec.message().c_str());
+++ return;
+++ }
+++
+++ ++num_incoming;
+++
+++ std::printf("[%4d] received incoming connection\n", millis);
+++ sock.close();
+++
+++ listener.async_accept(sock, std::bind(&incoming_connection
+++ , _1, std::ref(sock), std::ref(listener)));
+++}
+++
+++void on_connected(boost::system::error_code const& ec
+++ , ip::tcp::socket& sock)
+++{
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++ if (ec)
+++ {
+++ std::printf("[%4d] error while connecting: %s\n", millis, ec.message().c_str());
+++ return;
+++ }
+++
+++ ++num_connected;
+++
+++ std::printf("[%4d] made outgoing connection\n", millis);
+++ sock.close();
+++
+++ if (++counter > 5) return;
+++
+++ boost::system::error_code err;
+++ sock.open(ip::tcp::v4(), err);
+++ if (err) std::printf("[%4d] open failed: %s\n", millis, err.message().c_str());
+++ sock.async_connect(ip::tcp::endpoint(ip::make_address("40.30.20.10")
+++ , 1337), std::bind(&on_connected, _1, std::ref(sock)));
+++}
+++
+++}
+++
+++TEST_CASE("accept a connection multiple times on the same socket", "[accept]")
+++{
+++ default_config cfg;
+++ simulation sim(cfg);
+++ io_context incoming_ios(sim, ip::make_address_v4("40.30.20.10"));
+++ io_context outgoing_ios(sim, ip::make_address_v4("10.20.30.40"));
+++ ip::tcp::acceptor listener(incoming_ios);
+++
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++
+++ boost::system::error_code ec;
+++ listener.open(ip::tcp::v4(), ec);
+++ if (ec) std::printf("[%4d] open failed: %s\n", millis, ec.message().c_str());
+++ listener.bind(ip::tcp::endpoint(ip::address(), 1337), ec);
+++ if (ec) std::printf("[%4d] bind failed: %s\n", millis, ec.message().c_str());
+++ listener.listen(10, ec);
+++ if (ec) std::printf("[%4d] listen failed: %s\n", millis, ec.message().c_str());
+++
+++ ip::tcp::socket incoming(incoming_ios);
+++ listener.async_accept(incoming
+++ , std::bind(&incoming_connection, _1, std::ref(incoming)
+++ , std::ref(listener)));
+++
+++ std::printf("[%4d] connecting\n", millis);
+++ ip::tcp::socket outgoing(outgoing_ios);
+++ outgoing.open(ip::tcp::v4(), ec);
+++ if (ec) std::printf("[%4d] open failed: %s\n", millis, ec.message().c_str());
+++ outgoing.async_connect(ip::tcp::endpoint(ip::make_address("40.30.20.10")
+++ , 1337), std::bind(&on_connected, _1, std::ref(outgoing)));
+++
+++ sim.run();
+++
+++ CHECK(num_incoming == 6);
+++ CHECK(num_connected == 6);
+++
+++ millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/multi_homed.cpp
++@@ -0,0 +1,212 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include <functional>
+++
+++#include "catch.hpp"
+++
+++#ifdef __GNUC__
+++// for CATCH's CHECK macro
+++#pragma GCC diagnostic ignored "-Wparentheses"
+++#endif
+++
+++using namespace sim;
+++using namespace sim::asio::ip;
+++using namespace sim::chrono;
+++using sim::simulation;
+++using sim::default_config;
+++using namespace std::placeholders;
+++
+++namespace {
+++
+++char receive_buf[1000];
+++char send_buf[1000];
+++
+++int num_ipv6 = 0;
+++int num_ipv4 = 0;
+++
+++}
+++
+++void on_receive(boost::system::error_code const& ec, std::size_t /* bytes_transferred */
+++ , udp::socket& s)
+++{
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++
+++ if (ec)
+++ {
+++ std::printf("[%4d] error while receiving: %s\n", millis, ec.message().c_str());
+++ return;
+++ }
+++
+++ std::printf("[%4d] received packet on %s\n", millis,
+++ s.local_endpoint().address().to_string().c_str());
+++
+++ if (s.local_endpoint().address().is_v4())
+++ {
+++ ++num_ipv4;
+++ }
+++ else
+++ {
+++ ++num_ipv6;
+++ }
+++}
+++
+++TEST_CASE("one node can have multiple addresses (UDP)", "[multi-homed]")
+++{
+++ default_config cfg;
+++ simulation sim(cfg);
+++
+++ // the machine receiving packets has two IP addresses
+++ asio::io_context incoming_ios(sim, {
+++ make_address_v4("40.30.20.10"),
+++ make_address_v6("ff::dead:beef:1337")} );
+++ asio::io_context outgoing_ios(sim, make_address_v4("10.20.30.40"));
+++
+++ // we create two sockets for it, one for each interface
+++ udp::socket incoming_v4(incoming_ios);
+++ udp::socket incoming_v6(incoming_ios);
+++ udp::socket outgoing(outgoing_ios);
+++
+++ boost::system::error_code ec;
+++ incoming_v4.open(udp::v4(), ec);
+++ REQUIRE(!ec);
+++ incoming_v4.bind(udp::endpoint(make_address_v4("40.30.20.10"), 1337), ec);
+++ REQUIRE(!ec);
+++ incoming_v4.async_receive(asio::buffer(receive_buf
+++ , sizeof(receive_buf)), std::bind(&on_receive, _1, _2
+++ , std::ref(incoming_v4)));
+++
+++ incoming_v6.open(udp::v6(), ec);
+++ REQUIRE(!ec);
+++ incoming_v6.bind(udp::endpoint(make_address_v6("ff::dead:beef:1337"), 1337), ec);
+++ REQUIRE(!ec);
+++ incoming_v6.async_receive(asio::buffer(receive_buf
+++ , sizeof(receive_buf)), std::bind(&on_receive, _1, _2
+++ , std::ref(incoming_v6)));
+++
+++ outgoing.open(udp::v4(), ec);
+++ REQUIRE(!ec);
+++
+++ outgoing.non_blocking(true);
+++ REQUIRE(!ec);
+++
+++ // send a packet to the IPv4 address
+++ outgoing.send_to(asio::buffer(send_buf, sizeof(send_buf))
+++ , udp::endpoint(make_address_v4("40.30.20.10"), 1337), 0, ec);
+++ REQUIRE(!ec);
+++
+++ // and a packet to the IPv6 address
+++ outgoing.send_to(asio::buffer(send_buf, sizeof(send_buf))
+++ , udp::endpoint(make_address_v6("ff::dead:beef:1337"), 1337), 0, ec);
+++ REQUIRE(!ec);
+++
+++ sim.run();
+++
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++
+++ CHECK(millis == 43);
+++ CHECK(num_ipv4 == 1);
+++ CHECK(num_ipv6 == 1);
+++}
+++
+++TEST_CASE("one node can have multiple addresses (TCP)", "[multi-homed]")
+++{
+++ default_config cfg;
+++ simulation sim(cfg);
+++
+++ const unsigned short listen_port = 4242;
+++
+++ // the machine receiving packets has two IP addresses
+++ asio::io_context incoming_ios(sim, {
+++ make_address_v4("40.30.20.10"),
+++ make_address_v6("ff::dead:beef:1337")} );
+++
+++ // the machine sending packets has two IP addresses
+++ asio::io_context outgoing_ios(sim, {
+++ make_address_v4("10.20.30.40"),
+++ make_address_v6("ff::abad:cafe:1337")
+++ });
+++
+++ // we create two acceptors for it, one for each interface
+++ asio::ip::tcp::acceptor incoming_v4(incoming_ios);
+++ asio::ip::tcp::acceptor incoming_v6(incoming_ios);
+++
+++ tcp::socket outgoing_v4(outgoing_ios);
+++ tcp::socket outgoing_v6(outgoing_ios);
+++
+++ boost::system::error_code ec;
+++
+++ incoming_v4.open(tcp::v4(), ec);
+++ REQUIRE(!ec);
+++ incoming_v4.bind(tcp::endpoint(address_v4::any(), listen_port));
+++ REQUIRE(!ec);
+++ incoming_v4.listen();
+++
+++ incoming_v6.open(tcp::v6(), ec);
+++ REQUIRE(!ec);
+++ incoming_v6.bind(tcp::endpoint(address_v6::any(), listen_port));
+++ REQUIRE(!ec);
+++ incoming_v6.listen();
+++
+++ int num_incoming_v4 = 0;
+++ int num_incoming_v6 = 0;
+++
+++ tcp::socket incoming_socket(incoming_ios);
+++ incoming_v4.async_accept(incoming_socket, [&] (boost::system::error_code ec) {
+++ REQUIRE(!ec);
+++ CHECK(incoming_socket.remote_endpoint().address() == make_address_v4("10.20.30.40"));
+++ num_incoming_v4++;
+++ incoming_socket.close();
+++ });
+++
+++ incoming_v6.async_accept(incoming_socket, [&] (boost::system::error_code ec) {
+++ REQUIRE(!ec);
+++ CHECK(incoming_socket.remote_endpoint().address() == make_address_v6("ff::abad:cafe:1337"));
+++ num_incoming_v6++;
+++ incoming_socket.close();
+++ });
+++
+++ // connect via ipv4
+++ outgoing_v4.open(tcp::v4(), ec);
+++ REQUIRE(!ec);
+++ auto endpoint_v4 = asio::ip::tcp::endpoint(asio::ip::make_address("40.30.20.10"), listen_port);
+++ outgoing_v4.async_connect(endpoint_v4, [] (boost::system::error_code ec) {
+++ REQUIRE(!ec);
+++ });
+++ sim.run();
+++
+++ CHECK(num_incoming_v4 == 1);
+++ CHECK(num_incoming_v6 == 0);
+++
+++ // connect via ipv6
+++ outgoing_v6.open(tcp::v6(), ec);
+++ REQUIRE(!ec);
+++ auto endpoint_v6 = asio::ip::tcp::endpoint(asio::ip::make_address("ff::dead:beef:1337"), listen_port);
+++ outgoing_v6.async_connect(endpoint_v6, [] (boost::system::error_code ec) {
+++ REQUIRE(!ec);
+++ });
+++
+++ sim.run();
+++
+++ CHECK(num_incoming_v4 == 1);
+++ CHECK(num_incoming_v6 == 1);
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/null_buffers.cpp
++@@ -0,0 +1,200 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include <functional>
+++#include "catch.hpp"
+++
+++#ifdef __GNUC__
+++// for CATCH's CHECK macro
+++#pragma GCC diagnostic ignored "-Wparentheses"
+++#endif
+++
+++using namespace sim::asio;
+++using namespace sim::chrono;
+++using sim::simulation;
+++using sim::default_config;
+++using namespace std::placeholders;
+++
+++char send_buffer[10000];
+++char recv_buffer[10000];
+++int num_received = 0;
+++int num_sent = 0;
+++
+++void on_sent(boost::system::error_code const& ec, std::size_t bytes_transferred
+++ , ip::tcp::socket& sock)
+++{
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++ if (ec)
+++ {
+++ std::printf("[%4d] send error %s\n", millis, ec.message().c_str());
+++ return;
+++ }
+++
+++ num_sent += int(bytes_transferred);
+++ std::printf("[%4d] sent %d bytes (total: %d)\n"
+++ , millis, int(bytes_transferred), num_sent);
+++
+++ if (num_sent < 1000000)
+++ {
+++ sock.async_write_some(sim::asio::buffer(send_buffer
+++ , (std::min)(1000000 - num_sent, int(sizeof(send_buffer))))
+++ , std::bind(&on_sent, _1, _2, std::ref(sock)));
+++ return;
+++ }
+++ std::printf("closing\n");
+++ sock.close();
+++}
+++
+++void on_receive(boost::system::error_code const& ec, ip::tcp::socket& sock)
+++{
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++ if (ec)
+++ {
+++ std::printf("[%4d] receive error %s\n", millis, ec.message().c_str());
+++ return;
+++ }
+++
+++ boost::system::error_code err;
+++ std::size_t bytes_transferred = sock.read_some(sim::asio::buffer(
+++ recv_buffer, sizeof(recv_buffer)), err);
+++ if (err && err != boost::system::error_code(error::would_block))
+++ {
+++ std::printf("[%4d] receive error %s\n", millis, err.message().c_str());
+++ return;
+++ }
+++
+++ num_received += int(bytes_transferred);
+++
+++ std::printf("[%4d] received %d bytes (total: %d)\n"
+++ , millis, int(bytes_transferred), num_received);
+++
+++ sock.async_wait(ip::tcp::socket::wait_read
+++ , std::bind(&on_receive, _1, std::ref(sock)));
+++}
+++
+++void incoming_connection(boost::system::error_code const& ec
+++ , ip::tcp::socket& sock, ip::tcp::endpoint const& ep)
+++{
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++ if (ec)
+++ {
+++ std::printf("[%4d] error while accepting connection: %s\n"
+++ , millis, ec.message().c_str());
+++ return;
+++ }
+++
+++ boost::system::error_code err;
+++ ip::tcp::endpoint remote_endpoint = sock.remote_endpoint(err);
+++ if (ec) std::printf("[%4d] local_endpoint failed: %s\n", millis, ec.message().c_str());
+++ ip::tcp::endpoint local_endpoint = sock.local_endpoint(err);
+++ if (ec) std::printf("[%4d] remote_endpoint failed: %s\n", millis, ec.message().c_str());
+++ std::printf("[%4d] received incoming connection from: %s:%d. local endpoint: %s:%d\n"
+++ , millis, ep.address().to_string().c_str(), ep.port()
+++ , local_endpoint.address().to_string().c_str(), local_endpoint.port());
+++ CHECK(local_endpoint.port() == 1337);
+++ CHECK(local_endpoint.address().to_string() == "40.30.20.10");
+++ CHECK(remote_endpoint.port() != 0);
+++ CHECK(remote_endpoint.address().to_string() == "10.20.30.40");
+++
+++ sock.non_blocking(true);
+++ if (err) std::printf("[%4d] ioctl failed: %s\n", millis, err.message().c_str());
+++
+++ sock.async_wait(ip::tcp::socket::wait_read
+++ , std::bind(&on_receive, _1, std::ref(sock)));
+++}
+++
+++void on_connected(boost::system::error_code const& ec
+++ , ip::tcp::socket& sock)
+++{
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++ if (ec)
+++ {
+++ std::printf("[%4d] error while connecting: %s\n", millis, ec.message().c_str());
+++ return;
+++ }
+++
+++ boost::system::error_code err;
+++ ip::tcp::endpoint remote_endpoint = sock.remote_endpoint(err);
+++ if (ec) std::printf("[%4d] remote_endpoint failed: %s\n", millis, ec.message().c_str());
+++ ip::tcp::endpoint local_endpoint = sock.local_endpoint(err);
+++ if (ec) std::printf("[%4d] local_endpoint failed: %s\n", millis, ec.message().c_str());
+++ std::printf("[%4d] made outgoing connection to: %s:%d. local endpoint: %s:%d\n"
+++ , millis
+++ , remote_endpoint.address().to_string().c_str(), remote_endpoint.port()
+++ , local_endpoint.address().to_string().c_str(), local_endpoint.port());
+++
+++ CHECK(remote_endpoint.port() == 1337);
+++ CHECK(remote_endpoint.address().to_string() == "40.30.20.10");
+++ CHECK(local_endpoint.port() != 0);
+++ CHECK(local_endpoint.address().to_string() == "10.20.30.40");
+++
+++ std::printf("sending %d bytes\n", int(sizeof(send_buffer)));
+++ sock.async_write_some(sim::asio::buffer(send_buffer, sizeof(send_buffer))
+++ , std::bind(&on_sent, _1, _2, std::ref(sock)));
+++}
+++
+++TEST_CASE("receive null_buffers", "[null_buffers]")
+++{
+++ default_config cfg;
+++ simulation sim(cfg);
+++ io_context incoming_ios(sim, ip::make_address_v4("40.30.20.10"));
+++ io_context outgoing_ios(sim, ip::make_address_v4("10.20.30.40"));
+++ ip::tcp::acceptor listener(incoming_ios);
+++
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++
+++ boost::system::error_code ec;
+++ listener.open(ip::tcp::v4(), ec);
+++ if (ec) std::printf("[%4d] open failed: %s\n", millis, ec.message().c_str());
+++ listener.bind(ip::tcp::endpoint(ip::address(), 1337), ec);
+++ if (ec) std::printf("[%4d] bind failed: %s\n", millis, ec.message().c_str());
+++ listener.listen(10, ec);
+++ if (ec) std::printf("[%4d] listen failed: %s\n", millis, ec.message().c_str());
+++
+++ dump_network_graph(sim, "null_buffers.dot");
+++
+++ ip::tcp::socket incoming(incoming_ios);
+++ ip::tcp::endpoint remote_endpoint;
+++ listener.async_accept(incoming, remote_endpoint
+++ , std::bind(&incoming_connection, _1, std::ref(incoming)
+++ , std::cref(remote_endpoint)));
+++
+++ std::printf("[%4d] connecting\n", millis);
+++ ip::tcp::socket outgoing(outgoing_ios);
+++ outgoing.open(ip::tcp::v4(), ec);
+++ if (ec) std::printf("[%4d] open failed: %s\n", millis, ec.message().c_str());
+++ outgoing.async_connect(ip::tcp::endpoint(ip::make_address("40.30.20.10")
+++ , 1337), std::bind(&on_connected, _1, std::ref(outgoing)));
+++
+++ sim.run();
+++
+++ millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++ std::printf("num_sent: %d num_received: %d\n"
+++ , num_sent, num_received);
+++
+++ CHECK(num_received == num_sent);
+++ CHECK(num_received == 1000000);
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/parse_request.cpp
++@@ -0,0 +1,76 @@
+++/*
+++
+++Copyright (c) 2017, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include <functional>
+++
+++#include "catch.hpp"
+++#include "simulator/http_server.hpp" // for parse_request
+++
+++#ifdef __GNUC__
+++// for CATCH's CHECK macro
+++#pragma GCC diagnostic ignored "-Wparentheses"
+++#endif
+++
+++TEST_CASE("parse GET request", "[parse_request]")
+++{
+++ auto str = "GET /foo/bar?x=4 HTTP/1.1\r\n\r\n";
+++ sim::http_request req = sim::parse_request(str, static_cast<int>(std::strlen(str)));
+++ CHECK(req.method == "GET");
+++ CHECK(req.req == "/foo/bar?x=4");
+++ CHECK(req.path == "/foo/bar");
+++ CHECK(req.headers.empty());
+++}
+++
+++TEST_CASE("request path is normalized (no leading slash)", "[parse_request]")
+++{
+++ auto str = "GET foo/bar HTTP/1.1\r\n\r\n";
+++ sim::http_request req = sim::parse_request(str, static_cast<int>(std::strlen(str)));
+++ CHECK(req.path == "/foo/bar");
+++}
+++
+++TEST_CASE("request path is normalized (..)", "[parse_request]")
+++{
+++ auto str = "GET /foo/../foo/bar HTTP/1.1\r\n\r\n";
+++ sim::http_request req = sim::parse_request(str, static_cast<int>(std::strlen(str)));
+++ CHECK(req.path == "/foo/bar");
+++}
+++
+++TEST_CASE("parse CONNECT request", "[parse_request]")
+++{
+++ auto str = "CONNECT 192.168.0.1:8888 HTTP/1.1\r\n\r\n";
+++ sim::http_request req = sim::parse_request(str, static_cast<int>(std::strlen(str)));
+++ CHECK(req.method == "CONNECT");
+++ CHECK(req.req == "192.168.0.1:8888");
+++ CHECK(req.path == "192.168.0.1:8888");
+++ CHECK(req.headers.empty());
+++}
+++
+++TEST_CASE("headers are parsed", "[parse_request]")
+++{
+++ auto str = "GET / HTTP/1.1\r\nX-Foo: Bar\r\n\r\n";
+++ sim::http_request req = sim::parse_request(str, static_cast<int>(std::strlen(str)));
+++ CHECK(!req.headers.empty());
+++ CHECK(req.headers["x-foo"] == "Bar");
+++}
+++
+++TEST_CASE("invalid formed request throws parse exception", "[parse_request]")
+++{
+++ auto str = "INVALID";
+++ REQUIRE_THROWS_WITH(sim::parse_request(str, static_cast<int>(std::strlen(str))), Catch::Matchers::ContainsSubstring("parse failed"));
+++}
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/resolver.cpp
++@@ -0,0 +1,192 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include <functional>
+++
+++#include "catch.hpp"
+++
+++#ifdef __GNUC__
+++// for CATCH's CHECK macro
+++#pragma GCC diagnostic ignored "-Wparentheses"
+++#endif
+++
+++using namespace std::placeholders;
+++using namespace sim;
+++
+++using asio::ip::make_address_v4;
+++using asio::ip::address_v4;
+++using duration = chrono::high_resolution_clock::duration;
+++using chrono::duration_cast;
+++using chrono::milliseconds;
+++
+++int num_lookups = 0;
+++
+++void on_name_lookup(boost::system::error_code const& /* ec */
+++ , asio::ip::tcp::resolver::results_type ips)
+++{
+++ ++num_lookups;
+++
+++ std::vector<address_v4> expect = {
+++ make_address_v4("1.2.3.4")
+++ , make_address_v4("1.2.3.5")
+++ , make_address_v4("1.2.3.6")
+++ , make_address_v4("1.2.3.7") };
+++
+++ auto expect_it = expect.begin();
+++
+++ for (auto const& ip : ips)
+++ {
+++ assert(ip.endpoint().address() == *expect_it);
+++ assert(ip.endpoint().port() == 8080);
+++
+++ ++expect_it;
+++ }
+++
+++ assert(expect_it == expect.end());
+++}
+++
+++void on_failed_name_lookup(boost::system::error_code const& ec
+++ , asio::ip::tcp::resolver::results_type /* ips */)
+++{
+++ ++num_lookups;
+++
+++ assert(ec == boost::system::error_code(asio::error::host_not_found));
+++}
+++
+++struct sim_config : sim::default_config
+++{
+++ duration hostname_lookup(
+++ asio::ip::address const& requestor
+++ , std::string hostname
+++ , std::vector<asio::ip::address>& result
+++ , boost::system::error_code& ec)
+++ {
+++ if (hostname == "test.com")
+++ {
+++ result = {
+++ make_address_v4("1.2.3.4")
+++ , make_address_v4("1.2.3.5")
+++ , make_address_v4("1.2.3.6")
+++ , make_address_v4("1.2.3.7")
+++ };
+++ return duration_cast<duration>(chrono::milliseconds(50));
+++ }
+++
+++ return default_config::hostname_lookup(requestor, hostname, result, ec);
+++ }
+++};
+++
+++TEST_CASE("resolve multiple IPv4 addresses", "[resolver]") {
+++ sim_config cfg;
+++ simulation sim(cfg);
+++
+++ chrono::high_resolution_clock::time_point start = chrono::high_resolution_clock::now();
+++ num_lookups = 0;
+++
+++ asio::io_context ios(sim, make_address_v4("40.30.20.10"));
+++
+++ asio::ip::tcp::resolver resolver(ios);
+++ resolver.async_resolve("test.com", "8080"
+++ , std::bind(&on_name_lookup, _1, _2));
+++
+++ sim.run();
+++
+++ int millis = int(duration_cast<milliseconds>(chrono::high_resolution_clock::now() - start).count());
+++
+++ CHECK(millis == 50);
+++ CHECK(num_lookups == 1);
+++}
+++
+++TEST_CASE("resolve non-existent hostname", "[resolver]") {
+++ sim_config cfg;
+++ simulation sim(cfg);
+++
+++ chrono::high_resolution_clock::time_point start = chrono::high_resolution_clock::now();
+++ num_lookups = 0;
+++
+++ asio::io_context ios(sim, make_address_v4("40.30.20.10"));
+++
+++ asio::ip::tcp::resolver resolver(ios);
+++ resolver.async_resolve("non-existent.com", "8080"
+++ , std::bind(&on_failed_name_lookup, _1, _2));
+++
+++ sim.run();
+++
+++ int millis = int(duration_cast<milliseconds>(chrono::high_resolution_clock::now() - start).count());
+++
+++ CHECK(millis == 100);
+++ CHECK(num_lookups == 1);
+++}
+++
+++TEST_CASE("lookups resolve serially, compounding the latency", "[resolver]") {
+++ sim_config cfg;
+++ simulation sim(cfg);
+++
+++ chrono::high_resolution_clock::time_point start = chrono::high_resolution_clock::now();
+++ num_lookups = 0;
+++
+++ asio::io_context ios(sim, make_address_v4("40.30.20.10"));
+++
+++ asio::ip::tcp::resolver resolver(ios);
+++ resolver.async_resolve("non-existent.com", "8080", std::bind(&on_failed_name_lookup, _1, _2));
+++ resolver.async_resolve("non-existent.com", "8080", std::bind(&on_failed_name_lookup, _1, _2));
+++
+++ sim.run();
+++
+++ int millis = int(duration_cast<milliseconds>(chrono::high_resolution_clock::now() - start).count());
+++
+++ CHECK(millis == 200);
+++ CHECK(num_lookups == 2);
+++}
+++
+++TEST_CASE("resolve an IP address", "[resolver]") {
+++ sim_config cfg;
+++ simulation sim(cfg);
+++
+++ chrono::high_resolution_clock::time_point start = chrono::high_resolution_clock::now();
+++ num_lookups = 0;
+++
+++ asio::io_context ios(sim, make_address_v4("40.30.20.10"));
+++
+++ asio::ip::tcp::resolver resolver(ios);
+++ resolver.async_resolve("10.10.10.10", "8080"
+++ , [](boost::system::error_code const& /* ec */, asio::ip::tcp::resolver::results_type ips)
+++ {
+++ ++num_lookups;
+++ std::vector<address_v4> expect = { make_address_v4("10.10.10.10") };
+++
+++ auto expect_it = expect.begin();
+++ for (auto const& ip : ips)
+++ {
+++ assert(ip.endpoint().address() == *expect_it);
+++ assert(ip.endpoint().port() == 8080);
+++ ++expect_it;
+++ }
+++
+++ assert(expect_it == expect.end());
+++ });
+++
+++ sim.run();
+++
+++ int millis = int(duration_cast<milliseconds>(chrono::high_resolution_clock::now() - start).count());
+++
+++ CHECK(millis == 0);
+++ CHECK(num_lookups == 1);
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/timer.cpp
++@@ -0,0 +1,91 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include <functional>
+++
+++#include "catch.hpp"
+++
+++#ifdef __GNUC__
+++// for CATCH's CHECK macro
+++#pragma GCC diagnostic ignored "-Wparentheses"
+++#endif
+++
+++using namespace sim::chrono;
+++using namespace sim::asio;
+++using sim::simulation;
+++using sim::default_config;
+++using namespace std::placeholders;
+++
+++namespace {
+++
+++ int counter = 0;
+++ const int expected_timestamps[] = {1000, 2000, 4000, 7000, 11000 };
+++
+++ high_resolution_clock::time_point start;
+++}
+++
+++void print_time(high_resolution_timer& timer
+++ , boost::system::error_code const& ec)
+++{
+++ using namespace sim::chrono;
+++
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now() - start).count());
+++
+++ std::printf("[%d] timer fired at: %d milliseconds. error: %s\n"
+++ , counter
+++ , millis
+++ , ec.message().c_str());
+++
+++ if (ec)
+++ {
+++ CHECK(millis == 0);
+++ return;
+++ }
+++
+++ CHECK(millis == expected_timestamps[counter]);
+++
+++ ++counter;
+++ if (counter < 5)
+++ {
+++ timer.expires_after(seconds(counter));
+++ timer.async_wait(std::bind(&print_time, std::ref(timer), _1));
+++ }
+++}
+++
+++TEST_CASE("wait for timers", "[timer]")
+++{
+++ default_config cfg;
+++ simulation sim(cfg);
+++ io_context ios(sim, ip::make_address_v4("1.2.3.4"));
+++ high_resolution_timer timer(ios);
+++
+++ start = high_resolution_clock::now();
+++
+++ timer.expires_after(seconds(10));
+++ timer.async_wait(std::bind(&print_time, std::ref(timer), _1));
+++
+++ timer.cancel();
+++ timer.expires_after(seconds(1));
+++ timer.async_wait(std::bind(&print_time, std::ref(timer), _1));
+++
+++ sim.run();
+++
+++ CHECK(counter == 5);
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/test/udp_socket.cpp
++@@ -0,0 +1,114 @@
+++/*
+++
+++Copyright (c) 2015, Arvid Norberg
+++All rights reserved.
+++
+++ This program is free software: you can redistribute it and/or modify
+++ it under the terms of the GNU General Public License as published by
+++ the Free Software Foundation, either version 3 of the License, or
+++ (at your option) any later version.
+++ This program is distributed in the hope that it will be useful,
+++ but WITHOUT ANY WARRANTY; without even the implied warranty of
+++ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+++ GNU General Public License for more details.
+++ You should have received a copy of the GNU General Public License
+++ along with this program. If not, see <http://www.gnu.org/licenses/>.
+++
+++*/
+++
+++#include "simulator/simulator.hpp"
+++#include <functional>
+++#include <cstdio> // for printf
+++#include "catch.hpp"
+++
+++#ifdef __GNUC__
+++// for CATCH's CHECK macro
+++#pragma GCC diagnostic ignored "-Wparentheses"
+++#endif
+++
+++using namespace sim;
+++using namespace sim::asio::ip;
+++using namespace sim::chrono;
+++using sim::simulation;
+++using sim::default_config;
+++using namespace std::placeholders;
+++
+++namespace {
+++
+++char receive_buf[1000];
+++char send_buf[1000];
+++
+++int num_sent = 0;
+++int num_received = 0;
+++
+++void on_receive(boost::system::error_code const& ec, std::size_t bytes_transferred
+++ , udp::socket& s, udp::endpoint& ep)
+++{
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++
+++ if (ec)
+++ {
+++ std::printf("[%4d] error while receiving: %s\n", millis, ec.message().c_str());
+++ return;
+++ }
+++
+++ num_received += int(bytes_transferred);
+++
+++ std::printf("[%4d] received %d bytes from %s\n", millis
+++ , int(bytes_transferred)
+++ , ep.address().to_string().c_str());
+++
+++ if (bytes_transferred == 100 * 10) return;
+++
+++ s.async_receive_from(asio::buffer(receive_buf
+++ , sizeof(receive_buf)), ep, std::bind(&on_receive, _1, _2
+++ , std::ref(s), std::ref(ep)));
+++}
+++
+++}
+++
+++TEST_CASE("send packet to udp socket", "[udp_socket]")
+++{
+++ default_config cfg;
+++ simulation sim(cfg);
+++ asio::io_context incoming_ios(sim, make_address_v4("40.30.20.10"));
+++ asio::io_context outgoing_ios(sim, make_address_v4("10.20.30.40"));
+++
+++ udp::socket incoming(incoming_ios);
+++ udp::socket outgoing(outgoing_ios);
+++
+++ boost::system::error_code ec;
+++ incoming.open(udp::v4(), ec);
+++ REQUIRE(!ec);
+++ incoming.bind(udp::endpoint(address(), 1337), ec);
+++ REQUIRE(!ec);
+++
+++ outgoing.open(udp::v4(), ec);
+++ REQUIRE(!ec);
+++
+++ udp::endpoint remote_endpoint;
+++ incoming.async_receive_from(asio::buffer(receive_buf,
+++ sizeof(receive_buf)), remote_endpoint, std::bind(&on_receive, _1, _2
+++ , std::ref(incoming), std::ref(remote_endpoint)));
+++
+++ outgoing.non_blocking(true);
+++ REQUIRE(!ec);
+++
+++ for (int i = 1; i < 10; ++i)
+++ {
+++ num_sent += int(outgoing.send_to(asio::buffer(send_buf, 100 * i)
+++ , udp::endpoint(make_address_v4("40.30.20.10"), 1337), 0, ec));
+++ REQUIRE(!ec);
+++ }
+++
+++ sim.run();
+++
+++ int millis = int(duration_cast<milliseconds>(high_resolution_clock::now()
+++ .time_since_epoch()).count());
+++
+++ CHECK(millis == 56);
+++ CHECK(num_sent == num_received);
+++ CHECK(num_sent == 100 * 45);
+++}
+++
++--- /dev/null
+++++ libtorrent-rasterbar-2.0.14/simulation/libsimulator/user-config.jam
++@@ -0,0 +1,3 @@
+++using msvc : 14.1 ;
+++using gcc ;
+++
projects / libtorrent-rasterbar.git / commitdiff